@saltcorn/data 1.5.4 → 1.5.5

package/dist/tests/calc.test.js

@@ -1,1081 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const table_1 = __importDefault(require("../models/table"));
-const field_1 = __importDefault(require("../models/field"));
-const trigger_1 = __importDefault(require("../models/trigger"));
-const db_1 = __importDefault(require("../db"));
-const { getState } = require("../db/state");
-const mocks_1 = __importDefault(require("./mocks"));
-const { plugin_with_routes, sleep } = mocks_1.default;
-const expression_1 = __importDefault(require("../models/expression"));
-const { eval_expression, get_expression_function, transform_for_async, expressionValidator, jsexprToWhere, jsexprToSQL, freeVariables, freeVariablesInInterpolation, recalculate_for_stored, } = expression_1.default;
-const internal_1 = require("@saltcorn/db-common/internal");
-const assertions_1 = require("./assertions");
-const globals_1 = require("@jest/globals");
-const utils_1 = __importDefault(require("../utils"));
-const { interpolate, mergeIntoWhere } = utils_1.default;
-getState().registerPlugin("base", require("../base-plugin"));
-(0, globals_1.afterAll)(db_1.default.close);
-jest.setTimeout(30000);
-(0, globals_1.beforeAll)(async () => {
-    await require("../db/reset_schema")();
-    await require("../db/fixtures")();
-});
-(0, globals_1.describe)("eval_expression", () => {
-    (0, globals_1.it)("simply evaluates", () => {
-        (0, globals_1.expect)(eval_expression("x+2", { x: 5 })).toBe(7);
-    });
-    (0, globals_1.it)("uses code pages", async () => {
-        await getState().setConfig("function_code_pages", {
-            mypage: `function add58(x){return x+58}`,
-        });
-        await getState().refresh_codepages();
-        (0, globals_1.expect)(eval_expression("add58(x)", { x: 5 })).toBe(63);
-    });
-    (0, globals_1.it)("evaluates with null row", () => {
-        (0, globals_1.expect)(eval_expression("5+2", undefined)).toBe(7);
-        (0, globals_1.expect)(eval_expression("5+2", null)).toBe(7);
-        (0, globals_1.expect)(eval_expression("5+2")).toBe(7);
-    });
-});
-(0, globals_1.describe)("calculated", () => {
-    (0, globals_1.it)("how to use functions", () => {
-        const f = new Function("{x,y}", "return x+y");
-        (0, globals_1.expect)(f({ x: 1, y: 2 })).toBe(3);
-    });
-    (0, globals_1.it)("build table", async () => {
-        const table = await table_1.default.create("withcalcs");
-        await field_1.default.create({
-            table,
-            label: "x",
-            type: "Integer",
-        });
-        await field_1.default.create({
-            table,
-            label: "y",
-            type: "Integer",
-        });
-        const fz = await field_1.default.create({
-            table,
-            label: "z",
-            type: "Integer",
-            calculated: true,
-            expression: "x+y",
-        });
-        const fzid = await field_1.default.create({
-            table,
-            label: "zid",
-            type: "Integer",
-            calculated: true,
-            expression: "x+y+id",
-        });
-        const fw = await field_1.default.create({
-            table,
-            label: "w",
-            type: "Integer",
-            calculated: true,
-            expression: "y-x",
-            stored: true,
-        });
-        const fields = table.getFields();
-        const fzf = get_expression_function(fz.expression, fields);
-        (0, globals_1.expect)(fzf({ x: 4, y: 2 })).toBe(6);
-        await table.insertRow({ x: 5, y: 8 });
-        const [row] = await table.getRows();
-        (0, globals_1.expect)(row.z).toBe(13);
-        (0, globals_1.expect)(row.zid).toBe(14);
-        (0, globals_1.expect)(row.w).toBe(3);
-        const [row1] = await table.getJoinedRows();
-        (0, globals_1.expect)(row1.z).toBe(13);
-        (0, globals_1.expect)(row1.w).toBe(3);
-        const row0 = await table.getRow({});
-        (0, assertions_1.assertIsSet)(row0);
-        (0, globals_1.expect)(row0.z).toBe(13);
-        (0, globals_1.expect)(row0.w).toBe(3);
-        await table.updateRow({ y: 9 }, row.id);
-        const row2 = await table.getRow({});
-        (0, assertions_1.assertIsSet)(row2);
-        (0, globals_1.expect)(row2.z).toBe(14);
-        (0, globals_1.expect)(row2.w).toBe(4);
-        await table.update({ versioned: true });
-        const newid = await table.insertRow({ x: 2, y: 4 });
-        const row3 = await table.getRow({ id: newid });
-        (0, assertions_1.assertIsSet)(row3);
-        (0, globals_1.expect)(row3.z).toBe(6);
-        (0, globals_1.expect)(row3.w).toBe(2);
-        await fz.delete();
-        await fw.delete();
-    });
-    (0, globals_1.it)("cannot exit", async () => {
-        const table = await table_1.default.create("withcalcs2");
-        await field_1.default.create({
-            table,
-            label: "x",
-            type: "Integer",
-        });
-        const fz = await field_1.default.create({
-            table,
-            label: "z",
-            type: "Integer",
-            calculated: true,
-            expression: "process.exit(0)",
-        });
-        const fields = table.getFields();
-        (0, assertions_1.assertIsSet)(fz.expression);
-        const fzf = get_expression_function(fz.expression, fields);
-        let error;
-        try {
-            fzf({ x: 4 });
-        }
-        catch (e) {
-            error = e;
-        }
-        (0, globals_1.expect)(error.constructor.name).toContain("Error");
-    });
-    (0, globals_1.it)("stored existing", async () => {
-        const table = await table_1.default.create("withcalcs3");
-        await field_1.default.create({
-            table,
-            label: "x",
-            type: "Integer",
-        });
-        await field_1.default.create({
-            table,
-            label: "y",
-            type: "Integer",
-        });
-        const id1 = await table.insertRow({ x: 6, y: 9 });
-        for (let index = 0; index < 25; index++) {
-            await table.insertRow({ x: 1, y: 1 });
-        }
-        const id201 = await table.insertRow({ x: 7, y: 2 });
-        const fz = await field_1.default.create({
-            table,
-            label: "z",
-            type: "Integer",
-            calculated: true,
-            expression: "x+y",
-            stored: true,
-        });
-        const row0 = await table.getRow({ id: id1 });
-        (0, assertions_1.assertIsSet)(row0);
-        (0, globals_1.expect)(row0.x).toBe(6);
-        (0, globals_1.expect)([null, 15]).toContain(row0.z);
-        const row201 = await table.getRow({ id: id201 });
-        (0, assertions_1.assertIsSet)(row201);
-        (0, globals_1.expect)(row201.x).toBe(7);
-        (0, globals_1.expect)([null, 9]).toContain(row201.z);
-        await sleep(3000);
-        const row1 = await table.getRow({ id: id1 });
-        (0, assertions_1.assertIsSet)(row1);
-        (0, globals_1.expect)(row1.x).toBe(6);
-        (0, globals_1.expect)(row1.z).toBe(15);
-        const rowlast = await table.getRow({ id: id201 });
-        (0, assertions_1.assertIsSet)(rowlast);
-        (0, globals_1.expect)(rowlast.z).toBe(9);
-        (0, globals_1.expect)(rowlast.x).toBe(7);
-    });
-    (0, globals_1.it)("use supplied function", async () => {
-        const table = await table_1.default.create("withcalcs5");
-        await field_1.default.create({
-            table,
-            label: "x",
-            type: "Integer",
-        });
-        getState().registerPlugin("mock_plugin", plugin_with_routes());
-        await field_1.default.create({
-            table,
-            label: "z",
-            type: "Integer",
-            calculated: true,
-            expression: "add3(x)",
-        });
-        await field_1.default.create({
-            table,
-            label: "w",
-            type: "Integer",
-            calculated: true,
-            expression: "add5(x)",
-        });
-        await table.insertRow({ x: 13 });
-        const row0 = await table.getRow({});
-        (0, assertions_1.assertIsSet)(row0);
-        (0, globals_1.expect)(row0.z).toBe(16);
-        (0, globals_1.expect)(row0.w).toBe(18);
-    });
-    (0, globals_1.it)("use supplied function", async () => {
-        const table = await table_1.default.create("withcalcs7");
-        await field_1.default.create({
-            table,
-            label: "x",
-            type: "Integer",
-        });
-        getState().registerPlugin("mock_plugin", plugin_with_routes());
-        const xres = transform_for_async("add5(1)+ add3(4)+asyncAdd2(x)", getState().functions);
-        (0, globals_1.expect)(xres).toEqual({
-            expr_string: "add5(1) + add3(4) + await asyncAdd2(x)",
-            isAsync: true,
-        });
-        await field_1.default.create({
-            table,
-            label: "z",
-            type: "Integer",
-            calculated: true,
-            expression: "1+asyncAdd2(x)",
-            stored: true,
-        });
-        await field_1.default.create({
-            table,
-            label: "td",
-            type: "Date",
-            calculated: true,
-            expression: "today(-5)",
-            stored: true,
-        });
-        const id = await table.insertRow({ x: 14 });
-        const row0 = await table.getRow({});
-        (0, assertions_1.assertIsSet)(row0);
-        (0, globals_1.expect)(row0.z).toBe(17);
-        await table.updateRow({ x: 15 }, id);
-        const rows = await table.getRows({});
-        (0, globals_1.expect)(rows[0].z).toBe(18);
-        if (!db_1.default.isSQLite)
-            (0, globals_1.expect)(rows[0].td instanceof Date).toBe(true);
-    });
-});
-(0, globals_1.describe)("single joinfields in stored calculated fields", () => {
-    (0, globals_1.it)("creates", async () => {
-        const patients = table_1.default.findOne({ name: "patients" });
-        (0, assertions_1.assertIsSet)(patients);
-        const f = await field_1.default.create({
-            table: patients,
-            label: "favpages",
-            type: "Integer",
-            calculated: true,
-            expression: "favbook?.pages",
-            stored: true,
-        });
-        (0, globals_1.expect)(f.attributes.calc_joinfields.length).toBe(1);
-        (0, globals_1.expect)(f.attributes.calc_joinfields[0].targetTable).toBe("books");
-        (0, globals_1.expect)(f.attributes.calc_joinfields[0].field).toBe("favbook");
-    });
-    (0, globals_1.it)("updates", async () => {
-        const patients = table_1.default.findOne({ name: "patients" });
-        (0, assertions_1.assertIsSet)(patients);
-        const bookRows = await patients.getRows({});
-        for (const row of bookRows) {
-            await patients.updateRow({}, row.id);
-        }
-    });
-    (0, globals_1.it)("check", async () => {
-        const patients = table_1.default.findOne({ name: "patients" });
-        (0, assertions_1.assertIsSet)(patients);
-        const bookrow = await patients.getRow({ id: 1 });
-        (0, globals_1.expect)(bookrow?.favpages).toBe(967);
-    });
-    (0, globals_1.it)("changes", async () => {
-        const patients = table_1.default.findOne({ name: "patients" });
-        (0, assertions_1.assertIsSet)(patients);
-        await patients.updateRow({ favbook: 2 }, 1);
-        const bookrow = await patients.getRow({ id: 1 });
-        (0, globals_1.expect)(bookrow?.favpages).toBe(728);
-    });
-    (0, globals_1.it)("insert", async () => {
-        const patients = table_1.default.findOne({ name: "patients" });
-        (0, assertions_1.assertIsSet)(patients);
-        const hid = await patients.insertRow({ name: "Herman Smith", favbook: 1 });
-        const hrow = await patients.getRow({ id: hid });
-        (0, globals_1.expect)(hrow?.favpages).toBe(967);
-        //expect(bookrow?.favpages).toBe(967);
-    });
-    (0, globals_1.it)("recalculates", async () => {
-        const patients = table_1.default.findOne({ name: "patients" });
-        (0, assertions_1.assertIsSet)(patients);
-        const patient = await patients.getRow({ id: 1 });
-        (0, assertions_1.assertIsSet)(patient);
-        (0, globals_1.expect)(patient.favbook).toBe(2);
-        (0, globals_1.expect)(patient.favpages).toBe(728);
-        const books = table_1.default.findOne({ name: "books" });
-        (0, assertions_1.assertIsSet)(books);
-        const book = await books.getRow({ id: patient.favbook });
-        (0, assertions_1.assertIsSet)(book);
-        (0, globals_1.expect)(book.pages).toBe(728);
-        await books.updateRow({ pages: 729 }, book.id);
-        //await recalculate_for_stored(patients, { id: 1 });
-        const patient1 = await patients.getRow({ id: 1 });
-        (0, assertions_1.assertIsSet)(patient1);
-        (0, globals_1.expect)(patient1.favpages).toBe(729);
-        await books.updateRow({ pages: 728 }, book.id);
-    });
-    (0, globals_1.it)("add reciprocal field for looped updates ", async () => {
-        const books = table_1.default.findOne({ name: "books" });
-        (0, assertions_1.assertIsSet)(books);
-        await field_1.default.create({
-            table: books,
-            label: "Number of fans",
-            type: "Integer",
-            calculated: true,
-            expression: "__aggregation",
-            attributes: {
-                aggregate: "Count",
-                aggwhere: "",
-                agg_field: "id@Integer",
-                agg_relation: "patients.favbook",
-                table: "patients",
-                ref: "favbook",
-            },
-            stored: true,
-        });
-        await field_1.default.create({
-            table: books,
-            label: "idp1",
-            type: "Integer",
-            calculated: true,
-            expression: "id+1",
-            stored: false,
-        });
-        await field_1.default.create({
-            table: books,
-            label: "storedsum",
-            type: "Integer",
-            calculated: true,
-            expression: "number_of_fans+idp1",
-            stored: true,
-        });
-    });
-    (0, globals_1.it)("change value without triggering infinite loop", async () => {
-        const patients = table_1.default.findOne({ name: "patients" });
-        (0, assertions_1.assertIsSet)(patients);
-        const patient = await patients.getRow({ id: 1 });
-        (0, assertions_1.assertIsSet)(patient);
-        const books = table_1.default.findOne({ name: "books" });
-        (0, assertions_1.assertIsSet)(books);
-        const book = await books.getRow({ id: patient.favbook });
-        (0, assertions_1.assertIsSet)(book);
-        (0, globals_1.expect)(book.pages).toBe(728);
-        await books.updateRow({ pages: 729 }, book.id);
-        await books.updateRow({ pages: 728 }, book.id);
-        const bid = await books.insertRow({ author: "Terry Eagleton", pages: 456 });
-        const book1 = await books.getRow({ id: bid });
-        (0, assertions_1.assertIsSet)(book1);
-        (0, globals_1.expect)(book1.storedsum).toBe(4);
-        await books.getField("number_of_fans").delete();
-        await books.getField("idp1").delete();
-        await books.getField("storedsum").delete();
-        await books.deleteRows({ id: bid });
-    });
-});
-(0, globals_1.describe)("bool arrays in stored calculated JSON fields", () => {
-    (0, globals_1.it)("creates", async () => {
-        getState().registerPlugin("mock_plugin", plugin_with_routes());
-        const patients = table_1.default.findOne({ name: "patients" });
-        (0, assertions_1.assertIsSet)(patients);
-        await field_1.default.create({
-            name: "normalised_readings",
-            label: "normalised_readings",
-            calculated: true,
-            stored: true,
-            expression: "__aggregation",
-            type: "JSON",
-            attributes: {
-                ref: "patient_id",
-                table: "readings",
-                aggwhere: "",
-                agg_field: "normalised@Bool",
-                aggregate: "Array_Agg",
-                agg_order_by: "",
-                agg_relation: "readings.patient_id",
-                unique_error_msg: null,
-            },
-            required: false,
-            table: patients,
-        });
-        // need this to avoid race condition with next test
-        await recalculate_for_stored(patients);
-    });
-    (0, globals_1.it)("has array content", async () => {
-        const patients = table_1.default.findOne({ name: "patients" });
-        (0, assertions_1.assertIsSet)(patients);
-        const pat = await patients.getRow({ id: 1 });
-        (0, assertions_1.assertIsSet)(pat);
-        (0, globals_1.expect)(Array.isArray(pat.normalised_readings)).toBe(true);
-        if (!db_1.default.isSQLite)
-            (0, globals_1.expect)(typeof pat.normalised_readings[0]).toBe("boolean");
-    });
-    (0, globals_1.it)("updates on changes", async () => {
-        const patients = table_1.default.findOne({ name: "patients" });
-        (0, assertions_1.assertIsSet)(patients);
-        const readings = table_1.default.findOne({ name: "readings" });
-        (0, assertions_1.assertIsSet)(readings);
-        const pat = await patients.getRow({ id: 1 });
-        (0, assertions_1.assertIsSet)(pat);
-        if (!db_1.default.isSQLite)
-            (0, globals_1.expect)(typeof pat.normalised_readings[0]).toBe("boolean");
-        const reads = await readings.getRows({ patient_id: 1 });
-        for (const read of reads)
-            await readings.updateRow({ normalised: false }, read.id);
-        const pat1 = await patients.getRow({ id: 1 });
-        (0, assertions_1.assertIsSet)(pat1);
-        (0, globals_1.expect)(Array.isArray(pat1.normalised_readings)).toBe(true);
-        if (!db_1.default.isSQLite)
-            (0, globals_1.expect)(typeof pat1.normalised_readings[0]).toBe("boolean");
-        if (db_1.default.isSQLite)
-            (0, globals_1.expect)(!!pat1.normalised_readings[0]).toBe(false);
-        else
-            (0, globals_1.expect)(pat1.normalised_readings[0]).toBe(false);
-    });
-    (0, globals_1.it)("updates on insert", async () => {
-        const patients = table_1.default.findOne({ name: "patients" });
-        (0, assertions_1.assertIsSet)(patients);
-        const readings = table_1.default.findOne({ name: "readings" });
-        (0, assertions_1.assertIsSet)(readings);
-        const pat0 = await patients.getRow({ id: 1 });
-        (0, assertions_1.assertIsSet)(pat0);
-        (0, globals_1.expect)(Array.isArray(pat0.normalised_readings)).toBe(true);
-        (0, globals_1.expect)(pat0.normalised_readings.length).toBe(2);
-        await readings.insertRow({
-            normalised: true,
-            patient_id: 1,
-            temperature: 39,
-        });
-        const pat1 = await patients.getRow({ id: 1 });
-        (0, assertions_1.assertIsSet)(pat1);
-        (0, globals_1.expect)(Array.isArray(pat1.normalised_readings)).toBe(true);
-        if (!db_1.default.isSQLite)
-            (0, globals_1.expect)(typeof pat1.normalised_readings[0]).toBe("boolean");
-        (0, globals_1.expect)(pat1.normalised_readings.length).toBe(3);
-    });
-});
-(0, globals_1.describe)("double joinfields in stored calculated fields", () => {
-    (0, globals_1.it)("creates", async () => {
-        const readings = table_1.default.findOne({ name: "readings" });
-        (0, assertions_1.assertIsSet)(readings);
-        const f = await field_1.default.create({
-            table: readings,
-            label: "favpages",
-            type: "Integer",
-            calculated: true,
-            expression: "patient_id?.favbook?.pages",
-            stored: true,
-        });
-        //console.log(f.attributes.calc_joinfields)
-    });
-    (0, globals_1.it)("recalculates if final value changes", async () => {
-        const readings = table_1.default.findOne({ name: "readings" });
-        (0, assertions_1.assertIsSet)(readings);
-        const patients = table_1.default.findOne({ name: "patients" });
-        (0, assertions_1.assertIsSet)(patients);
-        const patid = await patients.insertRow({ name: "Stephen Few", favbook: 2 });
-        const readid = await readings.insertRow({
-            patient_id: patid,
-            temperature: 37,
-        });
-        const reading = await readings.getRow({ id: readid });
-        (0, globals_1.expect)(reading?.favpages).toBe(728);
-        const patient = await patients.getRow({ id: patid });
-        (0, assertions_1.assertIsSet)(patient);
-        const books = table_1.default.findOne({ name: "books" });
-        (0, assertions_1.assertIsSet)(books);
-        const book = await books.getRow({ id: patient.favbook });
-        (0, globals_1.expect)(book?.pages).toBe(728);
-        await books.updateRow({ pages: 729 }, book?.id);
-        //await recalculate_for_stored(patients, { id: 1 });
-        const reading1 = await readings.getRow({ id: readid });
-        (0, globals_1.expect)(reading1?.favpages).toBe(729);
-        await books.updateRow({ pages: 728 }, book?.id);
-    });
-    (0, globals_1.it)("recalculates if intermediate value changes", async () => {
-        const readings = table_1.default.findOne({ name: "readings" });
-        (0, assertions_1.assertIsSet)(readings);
-        const patients = table_1.default.findOne({ name: "patients" });
-        (0, assertions_1.assertIsSet)(patients);
-        const patid = await patients.insertRow({
-            name: "Stephen Many",
-            favbook: 2,
-        });
-        const readid = await readings.insertRow({
-            patient_id: patid,
-            temperature: 37,
-        });
-        const reading = await readings.getRow({ id: readid });
-        (0, globals_1.expect)(reading?.favpages).toBe(728);
-        await patients.updateRow({ favbook: 1 }, patid);
-        //await recalculate_for_stored(readings, { id: readid });
-        const reading1 = await readings.getRow({ id: readid });
-        (0, globals_1.expect)(reading1?.favpages).toBe(967);
-    });
-});
-(0, globals_1.describe)("Simple aggregations in stored calculated fields", () => {
-    (0, globals_1.it)("creates", async () => {
-        const publisher = table_1.default.findOne({ name: "publisher" });
-        (0, assertions_1.assertIsSet)(publisher);
-        await field_1.default.create({
-            table: publisher,
-            label: "Number of books",
-            type: "Integer",
-            calculated: true,
-            expression: "__aggregation",
-            attributes: {
-                aggregate: "Count",
-                aggwhere: "",
-                agg_field: "id@Integer",
-                agg_relation: "books.publisher",
-                table: "books",
-                ref: "publisher",
-            },
-            stored: true,
-        });
-    });
-    (0, globals_1.it)("updates", async () => {
-        const publisher = table_1.default.findOne({ name: "publisher" });
-        (0, assertions_1.assertIsSet)(publisher);
-        const bookRows = await publisher.getRows({});
-        for (const row of bookRows) {
-            await publisher.updateRow({}, row.id);
-        }
-    });
-    (0, globals_1.it)("check", async () => {
-        const publisher = table_1.default.findOne({ name: "publisher" });
-        (0, assertions_1.assertIsSet)(publisher);
-        const bookrow = await publisher.getRow({ id: 1 });
-        (0, globals_1.expect)(bookrow?.number_of_books).toBe(1);
-    });
-    (0, globals_1.it)("insert", async () => {
-        const publisher = table_1.default.findOne({ name: "publisher" });
-        (0, assertions_1.assertIsSet)(publisher);
-        const hid = await publisher.insertRow({ name: "Collins" });
-        const hrow = await publisher.getRow({ id: hid });
-        (0, globals_1.expect)(hrow?.number_of_books).toBe(0);
-        const books = table_1.default.findOne({ name: "books" });
-        (0, assertions_1.assertIsSet)(books);
-        await books.insertRow({
-            author: "Murphy",
-            pages: 456,
-            publisher: hid,
-        });
-        //await recalculate_for_stored(publisher);
-        const hrow1 = await publisher.getRow({ id: hid });
-        (0, globals_1.expect)(hrow1?.number_of_books).toBe(1);
-        await books.insertRow({
-            author: "Tufte",
-            pages: 210,
-            publisher: hid,
-        });
-        //await recalculate_for_stored(publisher, { id: hid });
-        const hrow2 = await publisher.getRow({ id: hid });
-        (0, globals_1.expect)(hrow2?.number_of_books).toBe(2);
-        const trigger = await trigger_1.default.create({
-            action: "recalculate_stored_fields",
-            table_id: books.id,
-            when_trigger: "Insert",
-            configuration: {
-                table: "publisher",
-                where: "{id: publisher}",
-            },
-        });
-        const wid = await books.insertRow({
-            author: "West",
-            pages: 210,
-            publisher: hid,
-        });
-        await sleep(200);
-        const hrow3 = await publisher.getRow({ id: hid });
-        (0, globals_1.expect)(hrow3?.number_of_books).toBe(3);
-        await books.deleteRows({ id: wid });
-        const hrow4 = await publisher.getRow({ id: hid });
-        (0, globals_1.expect)(hrow4?.number_of_books).toBe(2);
-    });
-    (0, globals_1.it)("moves from one parent to another", async () => {
-        const publisher = table_1.default.findOne({ name: "publisher" });
-        (0, assertions_1.assertIsSet)(publisher);
-        const books = table_1.default.findOne({ name: "books" });
-        (0, assertions_1.assertIsSet)(books);
-        const ps = await publisher.getRows({}, { orderBy: "id" });
-        //console.log("ps", ps);
-        (0, globals_1.expect)(ps[1].number_of_books).toBe(0);
-        (0, globals_1.expect)(ps[2].number_of_books).toBe(2);
-        const cbook = await books.getRow({ publisher: 3 });
-        (0, assertions_1.assertIsSet)(cbook);
-        //await getState().setConfig("log_level", 6);
-        await books.updateRow({ publisher: 2 }, cbook.id);
-        //await recalculate_for_stored(publisher, {});
-        //await getState().setConfig("log_level", 1);
-        const ps1 = await publisher.getRows({}, { orderBy: "id" });
-        //onsole.log("ps1", ps1);
-        (0, globals_1.expect)(ps1[1].number_of_books).toBe(1);
-        (0, globals_1.expect)(ps1[2].number_of_books).toBe(1);
-    });
-    (0, globals_1.it)("creates and updates sum field", async () => {
-        const publisher = table_1.default.findOne({ name: "publisher" });
-        (0, assertions_1.assertIsSet)(publisher);
-        await field_1.default.create({
-            table: publisher,
-            label: "Sum of pages",
-            type: "Integer",
-            calculated: true,
-            expression: "__aggregation",
-            attributes: {
-                aggregate: "Sum",
-                aggwhere: "",
-                agg_field: "pages@Integer",
-                agg_relation: "books.publisher",
-                table: "books",
-                ref: "publisher",
-            },
-            stored: true,
-        });
-        const bookRows = await publisher.getRows({});
-        for (const row of bookRows) {
-            await publisher.updateRow({}, row.id);
-        }
-        const hrow3 = await publisher.getRow({ id: 1 });
-        (0, globals_1.expect)(hrow3?.sum_of_pages).toBe(728);
-        const books = table_1.default.findOne({ name: "books" });
-        (0, assertions_1.assertIsSet)(books);
-        const book = await books.getRow({ publisher: 1 });
-        (0, assertions_1.assertIsSet)(book);
-        await books.updateRow({ pages: 729 }, book.id);
-        const hrow4 = await publisher.getRow({ id: 1 });
-        (0, globals_1.expect)(hrow4?.sum_of_pages).toBe(729);
-        const bid = await books.insertRow({
-            pages: 11,
-            publisher: 1,
-            author: "Fizz Buzz",
-        });
-        const hrow5 = await publisher.getRow({ id: 1 });
-        (0, globals_1.expect)(hrow5?.sum_of_pages).toBe(740);
-        await books.deleteRows({ id: bid });
-    });
-});
-(0, globals_1.describe)("Sum-where aggregations in stored calculated fields", () => {
-    (0, globals_1.it)("creates and updates sum field", async () => {
-        const publisher = table_1.default.findOne({ name: "publisher" });
-        (0, assertions_1.assertIsSet)(publisher);
-        const books = table_1.default.findOne({ name: "books" });
-        (0, assertions_1.assertIsSet)(books);
-        await field_1.default.create({
-            table: books,
-            label: "Interesting",
-            type: "Bool",
-        });
-        await field_1.default.create({
-            table: publisher,
-            label: "Sum of pages2",
-            type: "Integer",
-            calculated: true,
-            expression: "__aggregation",
-            attributes: {
-                aggregate: "Sum",
-                aggwhere: "interesting == true",
-                agg_field: "pages@Integer",
-                agg_relation: "books.publisher",
-                table: "books",
-                ref: "publisher",
-            },
-            stored: true,
-        });
-        const bookRows = await publisher.getRows({});
-        for (const row of bookRows) {
-            await publisher.updateRow({}, row.id);
-        }
-        const book = await books.getRow({ publisher: 1 });
-        (0, assertions_1.assertIsSet)(book);
-        const bookid = await books.insertRow({
-            pages: 12,
-            publisher: 1,
-            author: "Fizz Buzz",
-            interesting: true,
-        });
-        const hrow4 = await publisher.getRow({ id: 1 });
-        (0, globals_1.expect)(hrow4?.sum_of_pages2).toBe(12);
-        await books.updateRow({ pages: 14 }, bookid);
-        const hrow6 = await publisher.getRow({ id: 1 });
-        (0, globals_1.expect)(hrow6?.sum_of_pages2).toBe(14);
-        const bid2 = await books.insertRow({
-            pages: 11,
-            publisher: 1,
-            author: "Fizz Buzz",
-            interesting: true,
-        });
-        const hrow5 = await publisher.getRow({ id: 1 });
-        (0, globals_1.expect)(hrow5?.sum_of_pages2).toBe(25);
-        await books.deleteRows({ id: bookid });
-        await books.deleteRows({ id: bid2 });
-    });
-});
-(0, globals_1.describe)("join-aggregations in stored calculated fields", () => {
-    (0, globals_1.it)("creates", async () => {
-        const books = table_1.default.findOne({ name: "books" });
-        (0, assertions_1.assertIsSet)(books);
-        await field_1.default.create({
-            table: books,
-            name: "books_same_pub",
-            label: "books_same_pub",
-            calculated: true,
-            stored: true,
-            expression: "__aggregation",
-            type: "Integer",
-            attributes: {
-                ref: "publisher",
-                table: "publisher->books",
-                aggwhere: "",
-                agg_field: "id@Integer",
-                aggregate: "Count",
-                agg_order_by: null,
-                agg_relation: "publisher->books.publisher",
-                unique_error_msg: null,
-            },
-        });
-        await recalculate_for_stored(books);
-    });
-    (0, globals_1.it)("check", async () => {
-        const books = table_1.default.findOne({ name: "books" });
-        (0, assertions_1.assertIsSet)(books);
-        const bookrow = await books.getRow({ id: 2 });
-        (0, globals_1.expect)(bookrow?.books_same_pub).toBe(1);
-        await books.insertRow({ author: "Boring bloke", pages: 54, publisher: 1 });
-        const bookrow1 = await books.getRow({ id: 2 });
-        (0, globals_1.expect)(bookrow1?.books_same_pub).toBe(2);
-    });
-});
-(0, globals_1.describe)("join-aggregations in stored calculated fields again", () => {
-    (0, globals_1.it)("creates", async () => {
-        const sumtable = await table_1.default.create("DateSummary");
-        const banktable = await table_1.default.create("Bank");
-        const xacttable = await table_1.default.create("Transaction");
-        await field_1.default.create({
-            table: banktable,
-            name: "name",
-            label: "Name",
-            type: "String",
-        });
-        await field_1.default.create({
-            table: sumtable,
-            name: "bankid",
-            label: "BankID",
-            type: "Key to Bank",
-        });
-        await field_1.default.create({
-            table: xacttable,
-            name: "tbankid",
-            label: "TBankID",
-            type: "Key to Bank",
-        });
-        await field_1.default.create({
-            table: xacttable,
-            name: "amount",
-            label: "Amount",
-            type: "Integer",
-        });
-        await field_1.default.create({
-            table: sumtable,
-            name: "sumamount",
-            label: "SumAmount",
-            type: "Integer",
-            calculated: true,
-            stored: true,
-            expression: "__aggregation",
-            attributes: {
-                ref: "tbankid",
-                table: "bankid->Transaction",
-                aggwhere: "", //"transactiondate == summarydate",
-                agg_field: "amount@Integer",
-                aggregate: "Sum",
-                agg_relation: "bankid->Transaction.tbankid",
-            },
-        });
-        await banktable.insertRow({ name: "Lloyds" });
-        await banktable.insertRow({ name: "Starling" });
-        await banktable.insertRow({ name: "HSBC" });
-        await sumtable.insertRow({ bankid: 2 });
-        await sumtable.insertRow({ bankid: 1 });
-        await sumtable.insertRow({ bankid: 3 });
-        await xacttable.insertRow({ tbankid: 2, amount: 10 });
-        //await recalculate_for_stored(sumtable);
-        const sumrow = await sumtable.getRow({ id: 1 });
-        (0, globals_1.expect)(sumrow?.sumamount).toBe(10);
-    });
-});
-(0, globals_1.describe)("expressionValidator", () => {
-    (0, globals_1.it)("validates correct", () => {
-        (0, globals_1.expect)(expressionValidator("2+2")).toBe(true);
-    });
-    (0, globals_1.it)("validates record literal", () => {
-        (0, globals_1.expect)(expressionValidator("{foo: 4}")).toBe(true);
-    });
-    (0, globals_1.it)("validates correct", () => {
-        (0, globals_1.expect)(expressionValidator("name.toUpperCase()")).toBe(true);
-    });
-    (0, globals_1.it)("invalidates incorrect", () => {
-        (0, globals_1.expect)(expressionValidator("2+")).toContain("Unexpected");
-    });
-});
-(0, globals_1.describe)("free variables", () => {
-    (0, globals_1.it)("empty", () => {
-        (0, globals_1.expect)([...freeVariables("2+2")]).toEqual([]);
-    });
-    (0, globals_1.it)("simple", () => {
-        (0, globals_1.expect)([...freeVariables("2+x")]).toEqual(["x"]);
-    });
-    (0, globals_1.it)("record access", () => {
-        (0, globals_1.expect)([...freeVariables("2+x.k")]).toEqual(["x.k"]);
-    });
-    (0, globals_1.it)("record double access", () => {
-        (0, globals_1.expect)([...freeVariables("x.k.y")]).toEqual(["x.k.y"]);
-    });
-    (0, globals_1.it)("record triple access", () => {
-        (0, globals_1.expect)([...freeVariables("1+x.k.y.z")]).toEqual(["x.k.y.z"]);
-    });
-    (0, globals_1.it)("record single and double access", () => {
-        (0, globals_1.expect)([...freeVariables("x.k.y+x.z")]).toEqual(["x.k.y", "x.z"]);
-    });
-    (0, globals_1.it)("record double access with function", () => {
-        (0, globals_1.expect)([...freeVariables("Math.floor(x.k)")]).toEqual(["Math", "x.k"]);
-        (0, globals_1.expect)([...freeVariables("Math.floor(x)")]).toEqual(["Math", "x"]);
-        (0, globals_1.expect)([...freeVariables("Math.floor(x.k.y)")]).toEqual(["Math", "x.k.y"]);
-        (0, globals_1.expect)([...freeVariables("Math.floor(x.k.y.w)")]).toEqual([
-            "Math",
-            "x.k.y.w",
-        ]);
-    });
-    (0, globals_1.it)("does not include match function calls", () => {
-        (0, globals_1.expect)([...freeVariables("x.k.match(/xx/)")]).toEqual(["x.k"]);
-        (0, globals_1.expect)([...freeVariables("x.k.map(g).includes(y)")]).toContain("x.k");
-        (0, globals_1.expect)([...freeVariables("myFun(k)")]).toEqual(["myFun", "k"]);
-        (0, globals_1.expect)([...freeVariables("myFun(x.k)")]).toEqual(["myFun", "x.k"]);
-        (0, globals_1.expect)([...freeVariables("Foo.myFun(x.k)")]).toEqual(["Foo", "x.k"]);
-        (0, globals_1.expect)([...freeVariables("foo.match(/xx/)")]).toEqual(["foo"]);
-        (0, globals_1.expect)([...freeVariables("foo[0]")]).toEqual(["foo"]);
-        (0, globals_1.expect)([...freeVariables("x.k.map(g)")]).toEqual(["x.k", "g"]);
-    });
-    (0, globals_1.it)("does not include length", () => {
-        (0, globals_1.expect)([...freeVariables("x.k.length")]).toEqual(["x.k"]);
-        (0, globals_1.expect)([...freeVariables("x.length")]).toEqual(["x"]);
-    });
-    (0, globals_1.it)("chain record access", () => {
-        (0, globals_1.expect)([...freeVariables("1+x?.k")]).toEqual(["x.k"]);
-    });
-    (0, globals_1.it)("user ownership with group", () => {
-        (0, globals_1.expect)([
-            ...freeVariables("user.books_by_editor.map(b=>b.id).includes(id)"),
-        ]).toContain("user.books_by_editor");
-    });
-    (0, globals_1.it)("in interpolation", () => {
-        (0, globals_1.expect)([...freeVariablesInInterpolation("hello {{2+x.k}}")]).toEqual([
-            "x.k",
-        ]);
-    });
-    (0, globals_1.it)("in unsafe interpolation", () => {
-        (0, globals_1.expect)([...freeVariablesInInterpolation("hello {{! x.k}}")]).toEqual([
-            "x.k",
-        ]);
-    });
-    (0, globals_1.it)("in unsafe interpolation", () => {
-        (0, globals_1.expect)([...freeVariablesInInterpolation("hello {{! foo}}")]).toEqual([
-            "foo",
-        ]);
-    });
-    (0, globals_1.it)("in interpolation", () => {
-        (0, globals_1.expect)([
-            ...freeVariablesInInterpolation("hello {{2+x.k}} there {{y.z}}"),
-        ]).toEqual(["x.k", "y.z"]);
-    });
-});
-(0, globals_1.describe)("interpolation", () => {
-    (0, globals_1.it)("interpolates simple", () => {
-        (0, globals_1.expect)(interpolate("hello {{ x }}", { x: 1 })).toBe("hello 1");
-        (0, globals_1.expect)(interpolate("hello {{ x }}", { x: "<script>alert(1)</script>" })).toBe("hello &lt;script&gt;alert(1)&lt;/script&gt;");
-        (0, globals_1.expect)(interpolate("hello {{! x }}", { x: "<script>alert(1)</script>" })).toBe("hello <script>alert(1)</script>");
-        //expect(interpolate("hello {{x}}", { x: 1 })).toBe("hello 1"); TODO
-    });
-});
-(0, globals_1.describe)("jsexprToSQL", () => {
-    (0, globals_1.it)("translates equality", () => {
-        (0, globals_1.expect)(jsexprToSQL("foo==4")).toEqual("(foo)=(4)");
-    });
-    (0, globals_1.it)("translates string equality", () => {
-        (0, globals_1.expect)(jsexprToSQL('foo=="bar"')).toEqual("(foo)=('bar')");
-        (0, globals_1.expect)(jsexprToSQL('foo!="bar"')).toEqual("(foo)!=('bar')");
-        (0, globals_1.expect)(jsexprToSQL('!(foo=="bar")')).toEqual("not ((foo)=('bar'))");
-    });
-    (0, globals_1.it)("translates bools", () => {
-        (0, globals_1.expect)(jsexprToSQL("foo==true")).toEqual("foo is true");
-        (0, globals_1.expect)(jsexprToSQL("foo==false")).toEqual("foo is false");
-    });
-    (0, globals_1.it)("translates null cmps", () => {
-        (0, globals_1.expect)(jsexprToSQL("foo===null")).toEqual("foo is null");
-        (0, globals_1.expect)(jsexprToSQL("foo==null")).toEqual("foo is null");
-        (0, globals_1.expect)(jsexprToSQL("foo!=null")).toEqual("foo is not null");
-        (0, globals_1.expect)(jsexprToSQL("foo!==null")).toEqual("foo is not null");
-    });
-    (0, globals_1.it)("translates and", () => {
-        (0, globals_1.expect)(jsexprToSQL("foo==true && x==2")).toEqual("(foo is true)and((x)=(2))");
-    });
-    (0, globals_1.it)("translates something mildly complex", () => {
-        (0, globals_1.expect)(jsexprToSQL('!(name==="roderick" && phone==null)')).toEqual("not (((name)=('roderick'))and(phone is null))");
-    });
-});
-(0, globals_1.describe)("mergeIntoWhere", () => {
-    (0, globals_1.it)("merges", () => {
-        (0, globals_1.expect)(mergeIntoWhere({ a: 1 }, { b: 2 })).toEqual({ a: 1, b: 2 });
-        (0, globals_1.expect)(mergeIntoWhere({ a: 1 }, { a: 2 })).toEqual({ a: [1, 2] });
-        (0, globals_1.expect)(mergeIntoWhere({ or: [{ a: 1 }, { a: 2 }] }, { or: [{ b: 3 }, { b: 4 }] })).toEqual({
-            and: [{ or: [{ a: 1 }, { a: 2 }] }, { or: [{ b: 3 }, { b: 4 }] }],
-        });
-    });
-});
-let x = {
-    and: [{ or: [{ a: 1 }, { a: 2 }] }, { or: [{ b: 3 }, { b: 4 }] }],
-    or: [{ b: 3 }, { b: 4 }],
-};
-(0, globals_1.describe)("jsexprToWhere", () => {
-    (0, globals_1.it)("translates equality", () => {
-        (0, globals_1.expect)(jsexprToWhere("foo==4")).toEqual({ foo: 4 });
-    });
-    (0, globals_1.it)("translates equality reverse", () => {
-        (0, globals_1.expect)(jsexprToWhere("4==foo")).toEqual({ foo: 4 });
-    });
-    (0, globals_1.it)("translates equal to col", () => {
-        (0, globals_1.expect)(jsexprToWhere("foo==bar").foo.description).toBe("bar");
-    });
-    (0, globals_1.it)("translates context", () => {
-        (0, globals_1.expect)(jsexprToWhere("foo==$bar", { bar: 5 })).toEqual({ foo: 5 });
-    });
-    (0, globals_1.it)("translates own context", () => {
-        (0, globals_1.expect)(jsexprToWhere("foo==$foo", { foo: 5 }, [{ name: "foo" }])).toEqual({ foo: 5 });
-    });
-    (0, globals_1.it)("translates context", () => {
-        const w = jsexprToWhere("$father !== null && married_to === $father", {
-            father: "1",
-        });
-        (0, globals_1.expect)(w).toEqual({ married_to: "1", not: { eq: ["1", null] } });
-    });
-    (0, globals_1.it)("translates context", () => {
-        const w = jsexprToWhere("$father !== null && married_to === $father", {});
-        (0, globals_1.expect)(w).toEqual({ married_to: null, not: { eq: [null, null] } });
-    });
-    (0, globals_1.it)("is null in sql", () => {
-        const w = jsexprToWhere("group !== null", {});
-        (0, globals_1.expect)(w).toEqual({ not: { group: null } });
-        const { where } = (0, internal_1.mkWhere)(w);
-        (0, globals_1.expect)(where).toEqual('where not ("group" is null)');
-    });
-    /* TODO
-  
-    it("double exclamation", () => {
-      const w = jsexprToWhere("!!group", {});
-      console.log(w);
-      
-      expect(w).toEqual({ not: { group: null } });
-  
-      const { where } = mkWhere(w);
-      expect(where).toEqual('where not ("group" is null)');
-    }); */
-    (0, globals_1.it)("translates greater than", () => {
-        (0, globals_1.expect)(jsexprToWhere("foo>4")).toEqual({ foo: { gt: 4 } });
-    });
-    (0, globals_1.it)("translates lte", () => {
-        (0, globals_1.expect)(jsexprToWhere("foo<=4")).toEqual({ foo: { lt: 4, equal: true } });
-    });
-    (0, globals_1.it)("translates join field", async () => {
-        const books = table_1.default.findOne({ name: "books" });
-        const fields = await books?.getFields();
-        (0, globals_1.expect)(jsexprToWhere("publisher.name=='AK Press'", {}, fields)).toEqual({
-            publisher: {
-                inSelect: {
-                    field: "id",
-                    table: "publisher",
-                    tenant: "public",
-                    where: { name: "AK Press" },
-                },
-            },
-        });
-    });
-    (0, globals_1.it)("access context subvars", () => {
-        (0, globals_1.expect)(jsexprToWhere("foo==user.id", { user: { id: 5 } })).toEqual({
-            foo: 5,
-        });
-    });
-    (0, globals_1.it)("access deep context subvars", () => {
-        (0, globals_1.expect)(jsexprToWhere("foo==user.address.id", { user: { address: { id: 5 } } })).toEqual({
-            foo: 5,
-        });
-    });
-    (0, globals_1.it)("access context subvars rev", () => {
-        (0, globals_1.expect)(jsexprToWhere("user.id===foo", { user: { id: 5 } })).toEqual({
-            foo: 5,
-        });
-    });
-    (0, globals_1.it)("still parses same var", () => {
-        //nexdot issue Where function not working well
-        (0, globals_1.expect)(jsexprToWhere("foo == $foo", { foo: "$foo" })).toEqual({
-            foo: "$foo",
-        });
-    });
-    (0, globals_1.it)("translates sums", () => {
-        (0, globals_1.expect)(jsexprToWhere("foo==4+3")).toEqual({ foo: 7 });
-        (0, globals_1.expect)(jsexprToWhere("foo==4+3+1")).toEqual({ foo: 8 });
-    });
-    (0, globals_1.it)("translates bools", () => {
-        (0, globals_1.expect)(jsexprToWhere("foo==true")).toEqual({ foo: true });
-        (0, globals_1.expect)(jsexprToWhere("foo==false")).toEqual({ foo: false });
-        (0, globals_1.expect)(jsexprToWhere("foo!==true")).toEqual({ not: { foo: true } });
-        (0, globals_1.expect)(jsexprToWhere("!(foo==true)")).toEqual({ not: { foo: true } });
-        (0, globals_1.expect)(jsexprToWhere('bar == "Zoo" && !(foo==true)')).toEqual({
-            bar: "Zoo",
-            not: { foo: true },
-        });
-        (0, globals_1.expect)(jsexprToWhere('(bar == "Zoo" || bar == "Baz" || bar == "Waz") && !(foo==true)')).toEqual({
-            or: [{ or: [{ bar: "Zoo" }, { bar: "Baz" }] }, { bar: "Waz" }],
-            not: { foo: true },
-        });
-        (0, globals_1.expect)(jsexprToWhere('(bar == "Zoo" || bar == "Baz") && (foo==false || foo==null)')).toEqual({
-            and: [
-                { or: [{ bar: "Zoo" }, { bar: "Baz" }] },
-                { or: [{ foo: false }, { foo: null }] },
-            ],
-        });
-    });
-    (0, globals_1.it)("jsexprToWhere equate constant", () => {
-        (0, globals_1.expect)(jsexprToWhere("user.clearance==5", { user: { clearance: 5 } })).toEqual({ eq: [5, 5] });
-        (0, globals_1.expect)(jsexprToWhere('user.clearance=="ALL"', { user: { clearance: "ALL" } })).toEqual({ eq: ["ALL", "ALL"] });
-        (0, globals_1.expect)(jsexprToWhere("user.clearance==5", { user: { clearance: 6 } })).toEqual({ eq: [6, 5] });
-        (0, globals_1.expect)(jsexprToWhere('user.clearance=="ALL"', { user: { clearance: "NONE" } })).toEqual({ eq: ["NONE", "ALL"] });
-    });
-    (0, globals_1.it)("translates date limits", () => {
-        (0, globals_1.expect)(jsexprToWhere("foo>=year+'-'+month+'-01'").foo.gt).toMatch(/^202/);
-    });
-    (0, globals_1.it)("translates today()", () => {
-        const todayW = jsexprToWhere("foo>=today()");
-        const today = todayW.foo.gt;
-        (0, globals_1.expect)(todayW.foo.equal).toEqual(true);
-        (0, globals_1.expect)(today).toMatch(/^202/);
-        (0, globals_1.expect)(jsexprToWhere("foo>=today(5)").foo.gt).toMatch(/^202/);
-        (0, globals_1.expect)(new Date(jsexprToWhere("foo>=today(5)").foo.gt) > new Date(today)).toEqual(true);
-        (0, globals_1.expect)(new Date(jsexprToWhere("foo>=today({startOf: 'week'})").foo.gt) <
-            new Date()).toEqual(true);
-        const eoweek = new Date(jsexprToWhere("foo>=today({endOf: 'week'})").foo.gt);
-        (0, globals_1.expect)(eoweek > new Date() || eoweek.toDateString() === new Date().toDateString()).toEqual(true);
-        (0, globals_1.expect)(jsexprToWhere("foo>=today(-5)").foo.gt).toMatch(/^202/);
-        (0, globals_1.expect)(new Date(jsexprToWhere("foo>=today(-5)").foo.gt) < new Date(today)).toEqual(true);
-        const pp1W = jsexprToWhere("foo >= today(-1) && foo < today()");
-        (0, globals_1.expect)(!!pp1W.foo[0].gt).toBe(true);
-        (0, globals_1.expect)(pp1W.foo[0].equal).toBe(true);
-        (0, globals_1.expect)(!!pp1W.foo[1].lt).toBe(true);
-        const ppW = jsexprToWhere("createdby == user.id && (foo >= today(-1) && foo < today())", { user: { id: 1 } });
-        (0, globals_1.expect)(ppW.createdby).toBe(1);
-        (0, globals_1.expect)(!!ppW.foo[0].gt).toBe(true);
-        (0, globals_1.expect)(!!ppW.foo[1].lt).toBe(true);
-    });
-    (0, globals_1.it)("translates new Date()", () => {
-        const todayW = jsexprToWhere("foo>=new Date()");
-        const today = todayW.foo.gt;
-        (0, globals_1.expect)(todayW.foo.equal).toEqual(true);
-        (0, globals_1.expect)(today instanceof Date).toBe(true);
-        (0, globals_1.expect)(today.toISOString()).toMatch(/^202/);
-    });
-});
-//# sourceMappingURL=calc.test.js.map