@saltcorn/data 0.6.3 → 0.6.4-beta.1

package/dist/tests/table.test.js

@@ -1,49 +1,57 @@
 "use strict";
-const Table = require("../models/table");
-const TableConstraint = require("../models/table_constraints");
-const Field = require("../models/field");
-const View = require("../models/view");
-const db = require("../db");
+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 table_constraints_1 = __importDefault(require("../models/table_constraints"));
+const field_1 = __importDefault(require("../models/field"));
+const view_1 = __importDefault(require("../models/view"));
+const db_1 = __importDefault(require("../db"));
 const { getState } = require("../db/state");
 getState().registerPlugin("base", require("../base-plugin"));
-const fs = require("fs").promises;
-const { rick_file, plugin_with_routes, mockReqRes } = require("./mocks");
-afterAll(db.close);
-beforeAll(async () => {
+const promises_1 = require("fs/promises");
+const mocks_1 = __importDefault(require("./mocks"));
+const { rick_file, plugin_with_routes, mockReqRes } = mocks_1.default;
+const assertions_1 = require("./assertions");
+const globals_1 = require("@jest/globals");
+(0, globals_1.afterAll)(db_1.default.close);
+(0, globals_1.beforeAll)(async () => {
     await require("../db/reset_schema")();
     await require("../db/fixtures")();
 });
 jest.setTimeout(30000);
-describe("TableIO", () => {
-    it("should store attributes", async () => {
-        const tc = await Table.create("mytesttable");
-        await Field.create({
+(0, globals_1.describe)("TableIO", () => {
+    (0, globals_1.it)("should store attributes", async () => {
+        const tc = await table_1.default.create("mytesttable");
+        await field_1.default.create({
             table: tc,
             name: "foo_height1",
             label: "height1",
             type: "Integer",
             attributes: { max: 18 },
         });
-        const fs = await db.selectOne("_sc_fields", { name: "foo_height1" });
-        expect(fs.table_id).toBe(tc.id);
-        expect(fs.table_id > 0).toBe(true);
-        expect(fs.id > 0).toBe(true);
+        const fs = await db_1.default.selectOne("_sc_fields", { name: "foo_height1" });
+        (0, globals_1.expect)(fs.table_id).toBe(tc.id);
+        (0, globals_1.expect)(fs.table_id > 0).toBe(true);
+        (0, globals_1.expect)(fs.id > 0).toBe(true);
         const fields = await tc.getFields();
-        expect(fields[1].attributes).toStrictEqual({ max: 18 });
+        (0, globals_1.expect)(fields[1].attributes).toStrictEqual({ max: 18 });
     });
 });
-describe("Table create", () => {
-    it("should create", async () => {
-        const tc = await Table.create("mytable1");
-        const tf = await Table.findOne({ id: tc.id });
-        expect(tf.external).toBe(false);
-        expect(tc.external).toBe(false);
-        expect(tf.name).toStrictEqual("mytable1");
-        expect(tf.sql_name).toStrictEqual(db.isSQLite ? '"mytable1"' : '"public"."mytable1"');
-    });
-    it("toggle bools", async () => {
-        const tc = await Table.create("mytable17");
-        await Field.create({
+(0, globals_1.describe)("Table create", () => {
+    (0, globals_1.it)("should create", async () => {
+        const tc = await table_1.default.create("mytable1");
+        const tf = await table_1.default.findOne({ id: tc.id });
+        (0, assertions_1.assertIsSet)(tf);
+        (0, globals_1.expect)(tf.external).toBe(false);
+        (0, globals_1.expect)(tc.external).toBe(false);
+        (0, globals_1.expect)(tf.name).toStrictEqual("mytable1");
+        (0, globals_1.expect)(tf.sql_name).toStrictEqual(db_1.default.isSQLite ? '"mytable1"' : '"public"."mytable1"');
+    });
+    (0, globals_1.it)("toggle bools", async () => {
+        const tc = await table_1.default.create("mytable17");
+        await field_1.default.create({
             table: tc,
             label: "Group",
             type: "Bool",
@@ -52,12 +60,13 @@ describe("Table create", () => {
         const tall_id = await tc.insertRow({ group: true });
         await tc.toggleBool(tall_id, "group");
         const row = await tc.getRow({ id: tall_id });
-        expect(row.group).toBe(false);
+        (0, assertions_1.assertIsSet)(row);
+        (0, globals_1.expect)(row.group).toBe(false);
     });
-    it("should create required field in empty table without default", async () => {
-        const mytable1 = await Table.findOne({ name: "mytable1" });
-        expect(!!mytable1).toBe(true);
-        await Field.create({
+    (0, globals_1.it)("should create required field in empty table without default", async () => {
+        const mytable1 = await table_1.default.findOne({ name: "mytable1" });
+        (0, globals_1.expect)(!!mytable1).toBe(true);
+        await field_1.default.create({
             table: mytable1,
             name: "height1",
             label: "height1",
@@ -65,86 +74,98 @@ describe("Table create", () => {
             required: true,
         });
     });
-    it("should insert", async () => {
-        const mytable1 = await Table.findOne({ name: "mytable1" });
-        expect(mytable1.name).toBe("mytable1");
-        const id = await db.insert(mytable1.name, { height1: 6 });
-        expect(typeof id).toBe("number");
-        expect(id > 0).toBe(true);
-        const row = await db.selectOne(mytable1.name, { id });
-        expect(row.height1).toBe(6);
-        await db.update(mytable1.name, { height1: 7 }, id);
-        const rowup = await db.selectOne(mytable1.name, { id });
-        expect(rowup.height1).toBe(7);
-    });
-    it("should select one or zero", async () => {
-        const rows = await db.select("mytable1", {});
-        expect(rows.length).toBe(1);
-        const row = await db.selectMaybeOne("mytable1", { id: rows[0].id });
-        expect(row.height1).toBe(7);
-        const norow = await db.selectMaybeOne("mytable1", { id: 789 });
-        expect(norow).toBe(null);
-        await expect((async () => await db.selectOne("mytable1", { id: 789 }))()).rejects.toThrow(Error);
-    });
-    it("should get distinct values", async () => {
-        const table = await Table.findOne({ name: "mytable1" });
+    (0, globals_1.it)("should insert", async () => {
+        const mytable1 = await table_1.default.findOne({ name: "mytable1" });
+        (0, assertions_1.assertIsSet)(mytable1);
+        (0, globals_1.expect)(mytable1.name).toBe("mytable1");
+        const id = await db_1.default.insert(mytable1.name, { height1: 6 });
+        (0, globals_1.expect)(typeof id).toBe("number");
+        (0, globals_1.expect)(id > 0).toBe(true);
+        const row = await db_1.default.selectOne(mytable1.name, { id });
+        (0, globals_1.expect)(row.height1).toBe(6);
+        await db_1.default.update(mytable1.name, { height1: 7 }, id);
+        const rowup = await db_1.default.selectOne(mytable1.name, { id });
+        (0, globals_1.expect)(rowup.height1).toBe(7);
+    });
+    (0, globals_1.it)("should select one or zero", async () => {
+        const rows = await db_1.default.select("mytable1", {});
+        (0, globals_1.expect)(rows.length).toBe(1);
+        const row = await db_1.default.selectMaybeOne("mytable1", { id: rows[0].id });
+        (0, globals_1.expect)(row.height1).toBe(7);
+        const norow = await db_1.default.selectMaybeOne("mytable1", { id: 789 });
+        (0, globals_1.expect)(norow).toBe(null);
+        await (0, globals_1.expect)((async () => await db_1.default.selectOne("mytable1", { id: 789 }))()).rejects.toThrow();
+    });
+    (0, globals_1.it)("should get distinct values", async () => {
+        const table = await table_1.default.findOne({ name: "mytable1" });
+        (0, assertions_1.assertIsSet)(table);
         const vs = await table.distinctValues("height1");
-        expect(vs).toEqual([7]);
+        (0, globals_1.expect)(vs).toEqual([7]);
     });
-    it("should delete", async () => {
-        const table = await Table.findOne({ name: "mytable1" });
+    (0, globals_1.it)("should delete", async () => {
+        const table = await table_1.default.findOne({ name: "mytable1" });
+        (0, assertions_1.assertIsSet)(table);
         await table.delete();
-        const table1 = await Table.find({ name: "mytable1" });
-        expect(table1.length).toBe(0);
+        const table1 = await table_1.default.find({ name: "mytable1" });
+        (0, globals_1.expect)(table1.length).toBe(0);
     });
 });
-describe("Table get data", () => {
-    it("should get rows", async () => {
-        const patients = await Table.findOne({ name: "patients" });
+(0, globals_1.describe)("Table get data", () => {
+    (0, globals_1.it)("should get rows", async () => {
+        const patients = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(patients);
         const all = await patients.getRows();
-        expect(all.length).toStrictEqual(2);
+        (0, globals_1.expect)(all.length).toStrictEqual(2);
     });
-    it("should get rows where name is Michael", async () => {
-        const patients = await Table.findOne({ name: "patients" });
+    (0, globals_1.it)("should get rows where name is Michael", async () => {
+        const patients = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(patients);
         const michaels = await patients.getRows({ name: "Michael Douglas" });
-        expect(michaels.length).toStrictEqual(1);
+        (0, assertions_1.assertIsSet)(michaels);
+        (0, globals_1.expect)(michaels.length).toStrictEqual(1);
     });
-    it("should get limited rows", async () => {
-        const patients = await Table.findOne({ name: "patients" });
+    (0, globals_1.it)("should get limited rows", async () => {
+        const patients = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(patients);
         const michaels = await patients.getRows({ name: { ilike: "Douglas" } }, { limit: 1, orderBy: "id", offset: 1 });
-        expect(michaels.length).toStrictEqual(1);
-        expect(michaels[0].name).toStrictEqual("Michael Douglas");
+        (0, globals_1.expect)(michaels.length).toStrictEqual(1);
+        (0, globals_1.expect)(michaels[0].name).toStrictEqual("Michael Douglas");
     });
-    it("should get rows by slug", async () => {
-        const books = await Table.findOne({ name: "books" });
+    (0, globals_1.it)("should get rows by slug", async () => {
+        const books = await table_1.default.findOne({ name: "books" });
+        (0, assertions_1.assertIsSet)(books);
         const all = await books.getRows({
             author: { slugify: "herman-melville" },
         });
-        expect(all.length).toStrictEqual(1);
-        expect(all[0].pages).toStrictEqual(967);
+        (0, globals_1.expect)(all.length).toStrictEqual(1);
+        (0, globals_1.expect)(all[0].pages).toStrictEqual(967);
     });
-    it("should get joined rows where name is Michael", async () => {
-        const patients = await Table.findOne({ name: "patients" });
+    (0, globals_1.it)("should get joined rows where name is Michael", async () => {
+        const patients = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(patients);
         const michaels = await patients.getJoinedRows({
             where: { name: "Michael Douglas" },
         });
-        expect(michaels.length).toStrictEqual(1);
-        expect(michaels[0].favbook).toBe(2);
+        (0, globals_1.expect)(michaels.length).toStrictEqual(1);
+        (0, globals_1.expect)(michaels[0].favbook).toBe(2);
     });
-    it("should get joined rows where name is not null", async () => {
-        const patients = await Table.findOne({ name: "patients" });
+    (0, globals_1.it)("should get joined rows where name is not null", async () => {
+        const patients = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(patients);
         const nameds = await patients.getJoinedRows({
             where: { not: { name: null } },
         });
-        expect(nameds.length).toStrictEqual(2);
+        (0, globals_1.expect)(nameds.length).toStrictEqual(2);
     });
-    it("should get rows in id range", async () => {
-        const patients = await Table.findOne({ name: "patients" });
+    (0, globals_1.it)("should get rows in id range", async () => {
+        const patients = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(patients);
         const rows = await patients.getRows({ id: [{ gt: 0 }, { lt: 10 }] });
-        expect(rows.length).toStrictEqual(2);
+        (0, globals_1.expect)(rows.length).toStrictEqual(2);
     });
-    it("should get rows by subselect", async () => {
-        const books = await Table.findOne({ name: "books" });
+    (0, globals_1.it)("should get rows by subselect", async () => {
+        const books = await table_1.default.findOne({ name: "books" });
+        (0, assertions_1.assertIsSet)(books);
         const nrows = await books.countRows({
             id: {
                 inSelect: {
@@ -154,29 +175,32 @@ describe("Table get data", () => {
                 },
             },
         });
-        expect(nrows).toStrictEqual(1);
+        (0, globals_1.expect)(nrows).toStrictEqual(1);
     });
-    it("should get joined rows with limit and order", async () => {
-        const patients = await Table.findOne({ name: "patients" });
+    (0, globals_1.it)("should get joined rows with limit and order", async () => {
+        const patients = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(patients);
         const all = await patients.getJoinedRows({
             limit: 2,
             orderBy: "id",
         });
-        expect(all.length).toStrictEqual(2);
-        expect(all[1].favbook).toBe(2);
+        (0, globals_1.expect)(all.length).toStrictEqual(2);
+        (0, globals_1.expect)(all[1].favbook).toBe(2);
     });
-    it("should get joined rows with limit and desc order", async () => {
-        const patients = await Table.findOne({ name: "patients" });
+    (0, globals_1.it)("should get joined rows with limit and desc order", async () => {
+        const patients = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(patients);
         const all = await patients.getJoinedRows({
             limit: 2,
             orderBy: "id",
             orderDesc: true,
         });
-        expect(all.length).toStrictEqual(2);
-        expect(all[0].favbook).toBe(2);
+        (0, globals_1.expect)(all.length).toStrictEqual(2);
+        (0, globals_1.expect)(all[0].favbook).toBe(2);
     });
-    it("should get joined rows with aggregations", async () => {
-        const patients = await Table.findOne({ name: "patients" });
+    (0, globals_1.it)("should get joined rows with aggregations", async () => {
+        const patients = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(patients);
         const michaels = await patients.getJoinedRows({
             orderBy: "id",
             aggregations: {
@@ -188,11 +212,12 @@ describe("Table get data", () => {
                 },
             },
         });
-        expect(michaels.length).toStrictEqual(2);
-        expect(Math.round(michaels[0].avg_temp)).toBe(38);
+        (0, globals_1.expect)(michaels.length).toStrictEqual(2);
+        (0, globals_1.expect)(Math.round(michaels[0].avg_temp)).toBe(38);
     });
-    it("should get joined rows with latest aggregations", async () => {
-        const patients = await Table.findOne({ name: "patients" });
+    (0, globals_1.it)("should get joined rows with latest aggregations", async () => {
+        const patients = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(patients);
         const michaels = await patients.getJoinedRows({
             orderBy: "id",
             aggregations: {
@@ -204,22 +229,24 @@ describe("Table get data", () => {
                 },
             },
         });
-        expect(michaels.length).toStrictEqual(2);
-        expect(Math.round(michaels[0].last_temp)).toBe(37);
+        (0, globals_1.expect)(michaels.length).toStrictEqual(2);
+        (0, globals_1.expect)(Math.round(michaels[0].last_temp)).toBe(37);
     });
-    it("should get double joined rows", async () => {
-        const readings = await Table.findOne({ name: "readings" });
+    (0, globals_1.it)("should get double joined rows", async () => {
+        const readings = await table_1.default.findOne({ name: "readings" });
+        (0, assertions_1.assertIsSet)(readings);
         const reads = await readings.getJoinedRows({
             orderBy: "id",
             joinFields: {
                 author: { ref: "patient_id", through: "favbook", target: "author" },
             },
         });
-        expect(reads.length).toStrictEqual(3);
-        expect(reads[0].author).toBe("Herman Melville");
+        (0, globals_1.expect)(reads.length).toStrictEqual(3);
+        (0, globals_1.expect)(reads[0].author).toBe("Herman Melville");
     });
-    it("should get joined rows with aggregations and joins", async () => {
-        const patients = await Table.findOne({ name: "patients" });
+    (0, globals_1.it)("should get joined rows with aggregations and joins", async () => {
+        const patients = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(patients);
         const michaels = await patients.getJoinedRows({
             orderBy: "id",
             aggregations: {
@@ -235,54 +262,61 @@ describe("Table get data", () => {
                 author: { ref: "favbook", target: "author" },
             },
         });
-        expect(michaels.length).toStrictEqual(2);
-        expect(Math.round(michaels[0].avg_temp)).toBe(38);
-        expect(michaels[1].author).toBe("Leo Tolstoy");
+        (0, globals_1.expect)(michaels.length).toStrictEqual(2);
+        (0, globals_1.expect)(Math.round(michaels[0].avg_temp)).toBe(38);
+        (0, globals_1.expect)(michaels[1].author).toBe("Leo Tolstoy");
     });
-    it("should support full text search", async () => {
-        const table = await Table.findOne({ name: "patients" });
+    (0, globals_1.it)("should support full text search", async () => {
+        const table = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(table);
         const fields = await table.getFields();
-        const rows = await db.select("patients", {
+        const rows = await db_1.default.select("patients", {
             _fts: { fields, searchTerm: "Douglas" },
         });
-        expect(rows.length).toBe(2);
+        (0, globals_1.expect)(rows.length).toBe(2);
     });
-    it("should enable versioning", async () => {
-        const table = await Table.findOne({ name: "patients" });
+    (0, globals_1.it)("should enable versioning", async () => {
+        const table = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(table);
         table.versioned = true;
         await table.update(table);
     });
-    it("should save version on insert", async () => {
-        const table = await Table.findOne({ name: "patients" });
+    (0, globals_1.it)("should save version on insert", async () => {
+        const table = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(table);
         await table.insertRow({ name: "Bunny foo-foo", favbook: 1 });
         const bunnyFooFoo = await table.getRow({ name: "Bunny foo-foo" });
+        (0, assertions_1.assertIsSet)(bunnyFooFoo);
         const history1 = await table.get_history(bunnyFooFoo.id);
-        expect(history1.length).toBe(1);
-        expect(history1[0].id).toBe(bunnyFooFoo.id);
-        expect(history1[0]._version).toBe(1);
-        expect(history1[0].name).toBe("Bunny foo-foo");
-    });
-    it("should save version on update", async () => {
-        const table = await Table.findOne({ name: "patients" });
+        (0, globals_1.expect)(history1.length).toBe(1);
+        (0, globals_1.expect)(history1[0].id).toBe(bunnyFooFoo.id);
+        (0, globals_1.expect)(history1[0]._version).toBe(1);
+        (0, globals_1.expect)(history1[0].name).toBe("Bunny foo-foo");
+    });
+    (0, globals_1.it)("should save version on update", async () => {
+        const table = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(table);
         const bunnyFooFoo = await table.getRow({ name: "Bunny foo-foo" });
+        (0, assertions_1.assertIsSet)(bunnyFooFoo);
         await table.updateRow({ name: "Goon" }, bunnyFooFoo.id);
         const history2 = await table.get_history(bunnyFooFoo.id);
-        expect(history2.length).toBe(2);
-        expect(history2[0].id).toBe(bunnyFooFoo.id);
-        expect(history2[0]._version).toBe(1);
-        expect(history2[0].name).toBe("Bunny foo-foo");
-        expect(history2[0].favbook).toBe(1);
-        expect(history2[1].id).toBe(bunnyFooFoo.id);
-        expect(history2[1]._version).toBe(2);
-        expect(history2[1].name).toBe("Goon");
-        expect(history2[1].favbook).toBe(1);
+        (0, globals_1.expect)(history2.length).toBe(2);
+        (0, globals_1.expect)(history2[0].id).toBe(bunnyFooFoo.id);
+        (0, globals_1.expect)(history2[0]._version).toBe(1);
+        (0, globals_1.expect)(history2[0].name).toBe("Bunny foo-foo");
+        (0, globals_1.expect)(history2[0].favbook).toBe(1);
+        (0, globals_1.expect)(history2[1].id).toBe(bunnyFooFoo.id);
+        (0, globals_1.expect)(history2[1]._version).toBe(2);
+        (0, globals_1.expect)(history2[1].name).toBe("Goon");
+        (0, globals_1.expect)(history2[1].favbook).toBe(1);
         const goon = await table.getRow({ id: bunnyFooFoo.id });
-        expect(goon.name).toBe("Goon");
-        expect(goon.favbook).toBe(1);
+        (0, assertions_1.assertIsSet)(goon);
+        (0, globals_1.expect)(goon.name).toBe("Goon");
+        (0, globals_1.expect)(goon.favbook).toBe(1);
     });
-    it("create field on version table", async () => {
-        const table = await Table.findOne({ name: "patients" });
-        const fc = await Field.create({
+    (0, globals_1.it)("create field on version table", async () => {
+        const table = await table_1.default.findOne({ name: "patients" });
+        const fc = await field_1.default.create({
             table: table,
             name: "Height19",
             label: "height19",
@@ -292,27 +326,28 @@ describe("Table get data", () => {
         });
         await fc.delete();
     });
-    it("should disable versioning", async () => {
-        const table = await Table.findOne({ name: "patients" });
+    (0, globals_1.it)("should disable versioning", async () => {
+        const table = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(table);
         await table.getFields();
         await table.update({ versioned: false });
     });
-    it("should rename", async () => {
-        const table = await Table.create("notsurename");
-        await Field.create({
+    (0, globals_1.it)("should rename", async () => {
+        const table = await table_1.default.create("notsurename");
+        await field_1.default.create({
             table,
             label: "tall",
             type: "Bool",
             required: true,
         });
-        const table1 = await Table.create("refsunsure");
-        await Field.create({
+        const table1 = await table_1.default.create("refsunsure");
+        await field_1.default.create({
             table: table1,
             label: "also_tall",
             type: "Bool",
             required: true,
         });
-        await Field.create({
+        await field_1.default.create({
             table: table1,
             label: "theref",
             type: "Key to notsurename",
@@ -322,23 +357,26 @@ describe("Table get data", () => {
         await table1.insertRow({ also_tall: true, theref: id });
         const joinFields = { reftall: { ref: "theref", target: "tall" } };
         const rows = await table1.getJoinedRows({ joinFields });
-        expect(rows[0].theref).toBe(id);
-        expect(!!rows[0].reftall).toBe(false); //for sqlite
-        if (!db.isSQLite) {
+        (0, globals_1.expect)(rows[0].theref).toBe(id);
+        (0, globals_1.expect)(!!rows[0].reftall).toBe(false); //for sqlite
+        if (!db_1.default.isSQLite) {
             await table.rename("isthisbetter");
-            const table3 = await Table.findOne({ name: "refsunsure" });
+            const table3 = await table_1.default.findOne({ name: "refsunsure" });
+            (0, assertions_1.assertIsSet)(table3);
             const rows1 = await table3.getJoinedRows({ joinFields });
-            expect(rows1[0].theref).toBe(id);
-            expect(rows1[0].reftall).toBe(false);
-            const table2 = await Table.findOne({ name: "isthisbetter" });
-            expect(!!table2).toBe(true);
+            (0, globals_1.expect)(rows1[0].theref).toBe(id);
+            (0, globals_1.expect)(rows1[0].reftall).toBe(false);
+            const table2 = await table_1.default.findOne({ name: "isthisbetter" });
+            (0, assertions_1.assertIsSet)(table2);
+            (0, globals_1.expect)(!!table2).toBe(true);
             table2.versioned = true;
             await table2.update(table2);
             await table2.rename("thisisthebestname");
         }
     });
-    it("should get joined rows with arbitrary fieldnames", async () => {
-        const patients = await Table.findOne({ name: "patients" });
+    (0, globals_1.it)("should get joined rows with arbitrary fieldnames", async () => {
+        const patients = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(patients);
         const michaels = await patients.getJoinedRows({
             where: { name: "Michael Douglas" },
             joinFields: {
@@ -346,27 +384,29 @@ describe("Table get data", () => {
                 author: { ref: "favbook", target: "author" },
             },
         });
-        expect(michaels.length).toStrictEqual(1);
-        expect(michaels[0].pages).toBe(728);
-        expect(michaels[0].author).toBe("Leo Tolstoy");
+        (0, globals_1.expect)(michaels.length).toStrictEqual(1);
+        (0, globals_1.expect)(michaels[0].pages).toBe(728);
+        (0, globals_1.expect)(michaels[0].author).toBe("Leo Tolstoy");
     });
-    it("should get joined rows with one-to-one relations", async () => {
-        const ratings = await Table.create("myreviews");
-        await Field.create({
+    (0, globals_1.it)("should get joined rows with one-to-one relations", async () => {
+        const ratings = await table_1.default.create("myreviews");
+        (0, assertions_1.assertIsSet)(ratings);
+        await field_1.default.create({
             name: "book",
             label: "Book",
             type: "Key to books",
             is_unique: true,
             table: ratings,
         });
-        await Field.create({
+        await field_1.default.create({
             name: "rating",
             label: "Rating",
             type: "Integer",
             table: ratings,
         });
         await ratings.insertRow({ book: 1, rating: 7 });
-        const books = await Table.findOne({ name: "books" });
+        const books = await table_1.default.findOne({ name: "books" });
+        (0, assertions_1.assertIsSet)(books);
         //db.set_sql_logging();
         const reads = await books.getJoinedRows({
             orderBy: "id",
@@ -375,42 +415,46 @@ describe("Table get data", () => {
                 rating: { ref: "book", ontable: "myreviews", target: "rating" },
             },
         });
-        expect(reads.length).toStrictEqual(1);
-        expect(reads[0].rating).toBe(7);
-        expect(reads[0].author).toBe("Herman Melville");
-        expect(reads[0].pages).toBe(967);
+        (0, globals_1.expect)(reads.length).toStrictEqual(1);
+        (0, globals_1.expect)(reads[0].rating).toBe(7);
+        (0, globals_1.expect)(reads[0].author).toBe("Herman Melville");
+        (0, globals_1.expect)(reads[0].pages).toBe(967);
     });
 });
-describe("relations", () => {
-    it("get parent relations", async () => {
-        const table = await Table.findOne({ name: "patients" });
+(0, globals_1.describe)("relations", () => {
+    (0, globals_1.it)("get parent relations", async () => {
+        const table = await table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(table);
         const rels = await table.get_parent_relations();
-        expect(rels.parent_field_list).toContain("favbook.author");
-        expect(rels.parent_relations.length).toBe(2);
+        (0, globals_1.expect)(rels.parent_field_list).toContain("favbook.author");
+        (0, globals_1.expect)(rels.parent_relations.length).toBe(2);
     });
-    it("get parent relations with one-to-one", async () => {
-        const table = await Table.findOne({ name: "books" });
+    (0, globals_1.it)("get parent relations with one-to-one", async () => {
+        const table = await table_1.default.findOne({ name: "books" });
+        (0, assertions_1.assertIsSet)(table);
         const rels = await table.get_parent_relations();
-        expect(rels.parent_field_list).toEqual([
+        (0, globals_1.expect)(rels.parent_field_list).toEqual([
             "myreviews.book->book",
             "myreviews.book->id",
             "myreviews.book->rating",
         ]);
     });
-    it("get child relations", async () => {
-        const table = await Table.findOne({ name: "books" });
+    (0, globals_1.it)("get child relations", async () => {
+        const table = await table_1.default.findOne({ name: "books" });
+        (0, assertions_1.assertIsSet)(table);
         const rels = await table.get_child_relations();
-        expect(rels.child_field_list).toEqual([
+        (0, globals_1.expect)(rels.child_field_list).toEqual([
             "discusses_books.book",
             "myreviews.book",
             "patients.favbook",
         ]);
-        expect(rels.child_relations.length).toBe(3);
+        (0, globals_1.expect)(rels.child_relations.length).toBe(3);
     });
-    it("get grandparent relations", async () => {
-        const table = await Table.findOne({ name: "readings" });
+    (0, globals_1.it)("get grandparent relations", async () => {
+        const table = await table_1.default.findOne({ name: "readings" });
+        (0, assertions_1.assertIsSet)(table);
         const rels = await table.get_parent_relations(true);
-        expect(rels.parent_field_list).toEqual([
+        (0, globals_1.expect)(rels.parent_field_list).toEqual([
             "patient_id.favbook",
             "patient_id.favbook.author",
             "patient_id.favbook.id",
@@ -423,240 +467,266 @@ describe("relations", () => {
             "patient_id.parent.name",
             "patient_id.parent.parent",
         ]);
-        expect(rels.parent_relations.length).toBe(3);
+        (0, globals_1.expect)(rels.parent_relations.length).toBe(3);
     });
 });
-describe("CSV import", () => {
-    it("should import into existing table", async () => {
+(0, globals_1.describe)("CSV import", () => {
+    (0, globals_1.it)("should import into existing table", async () => {
         const csv = `author,Pages
 Joe Celko, 856
 Gordon Kane, 217`;
         const fnm = "/tmp/test1ok.csv";
-        await fs.writeFile(fnm, csv);
-        const table = await Table.findOne({ name: "books" });
-        expect(!!table).toBe(true);
+        await (0, promises_1.writeFile)(fnm, csv);
+        const table = await table_1.default.findOne({ name: "books" });
+        (0, assertions_1.assertIsSet)(table);
+        (0, globals_1.expect)(!!table).toBe(true);
         const impres = await table.import_csv_file(fnm);
-        expect(impres).toEqual({ success: "Imported 2 rows into table books" });
+        (0, globals_1.expect)(impres).toEqual({ success: "Imported 2 rows into table books" });
         const rows = await table.getRows({ author: "Gordon Kane" });
-        expect(rows.length).toBe(1);
-        expect(rows[0].pages).toBe(217);
+        (0, globals_1.expect)(rows.length).toBe(1);
+        (0, globals_1.expect)(rows[0].pages).toBe(217);
     });
-    it("fail on required field", async () => {
+    (0, globals_1.it)("fail on required field", async () => {
         const csv = `author,Pagez
 Joe Celko, 856
 Gordon Kane, 217`;
         const fnm = "/tmp/test1f.csv";
-        await fs.writeFile(fnm, csv);
-        const table = await Table.findOne({ name: "books" });
-        expect(!!table).toBe(true);
+        await (0, promises_1.writeFile)(fnm, csv);
+        const table = await table_1.default.findOne({ name: "books" });
+        (0, assertions_1.assertIsSet)(table);
+        (0, globals_1.expect)(!!table).toBe(true);
         const impres = await table.import_csv_file(fnm);
-        expect(impres).toEqual({ error: "Required field missing: Pages" });
+        (0, globals_1.expect)(impres).toEqual({ error: "Required field missing: Pages" });
     });
-    it("fail on strings in ints", async () => {
+    (0, globals_1.it)("fail on strings in ints", async () => {
         const csv = `author,Pages
 Leonardo Boff, 99
 David MacKay, ITILA`;
         const fnm = "/tmp/test1.csv";
-        await fs.writeFile(fnm, csv);
-        const table = await Table.create("books_not_req_pages", {
+        await (0, promises_1.writeFile)(fnm, csv);
+        const table = await table_1.default.create("books_not_req_pages", {
             min_role_read: 10,
         });
-        await Field.create({
+        await field_1.default.create({
             table,
             name: "author",
             label: "Author",
             type: "String",
             required: true,
         });
-        await Field.create({
+        await field_1.default.create({
             table,
             name: "pages",
             label: "Pages",
             type: "Integer",
             attributes: { min: 0 },
         });
-        expect(!!table).toBe(true);
+        (0, globals_1.expect)(!!table).toBe(true);
         const impres = await table.import_csv_file(fnm);
-        expect(impres).toEqual({
+        (0, globals_1.expect)(impres).toEqual({
             success: "Imported 1 rows into table books_not_req_pages. Rejected 1 rows.",
         });
         const rows = await table.getRows({ author: "David MacKay" });
-        expect(rows.length).toBe(0);
+        (0, globals_1.expect)(rows.length).toBe(0);
     });
-    it("should create by importing", async () => {
+    (0, globals_1.it)("should create by importing", async () => {
         //db.set_sql_logging();
         const csv = `item,cost,count, vatable
 Book, 5,4, f
 Pencil, 0.5,2, t`;
         const fnm = "/tmp/test2impok.csv";
-        await fs.writeFile(fnm, csv);
-        const { table } = await Table.create_from_csv("Invoice", fnm);
+        await (0, promises_1.writeFile)(fnm, csv);
+        const result = await table_1.default.create_from_csv("Invoice", fnm);
+        (0, assertions_1.assertsIsSuccessMessage)(result);
+        const { table } = result;
+        (0, assertions_1.assertIsSet)(table);
         const fields = await table.getFields();
         const vatField = fields.find((f) => f.name === "vatable");
-        expect(vatField.type.name).toBe("Bool");
+        (0, assertions_1.assertIsSet)(vatField);
+        (0, assertions_1.assertIsType)(vatField.type);
+        (0, globals_1.expect)(vatField.type.name).toBe("Bool");
         const costField = fields.find((f) => f.name === "cost");
-        expect(costField.type.name).toBe("Float");
+        (0, assertions_1.assertIsSet)(costField);
+        (0, assertions_1.assertIsType)(costField.type);
+        (0, globals_1.expect)(costField.type.name).toBe("Float");
         const countField = fields.find((f) => f.name === "count");
-        expect(countField.type.name).toBe("Integer");
+        (0, assertions_1.assertIsSet)(countField);
+        (0, assertions_1.assertIsType)(countField.type);
+        (0, globals_1.expect)(countField.type.name).toBe("Integer");
         const rows = await table.getRows({ item: "Pencil" });
-        expect(rows.length).toBe(1);
-        expect(rows[0].vatable).toBe(true);
+        (0, globals_1.expect)(rows.length).toBe(1);
+        (0, globals_1.expect)(rows[0].vatable).toBe(true);
         const allrows = await table.getRows();
-        expect(allrows.length).toBe(2);
+        (0, globals_1.expect)(allrows.length).toBe(2);
     });
-    it("should fail on bad col nm", async () => {
+    (0, globals_1.it)("should fail on bad col nm", async () => {
         const csv = `item,cost,!, vatable
 Book, 5,4, f
 Pencil, 0.5,2, t`;
         const fnm = "/tmp/test2.csv";
-        await fs.writeFile(fnm, csv);
-        const res = await Table.create_from_csv("Invoice1", fnm);
-        expect(res).toEqual({
+        await (0, promises_1.writeFile)(fnm, csv);
+        const res = await table_1.default.create_from_csv("Invoice1", fnm);
+        (0, globals_1.expect)(res).toEqual({
             error: "Invalid column name ! - Use A-Z, a-z, 0-9, _ only",
         });
-        const table = await Table.findOne({ name: "Invoice1" });
-        expect(table).toBe(null);
+        const table = await table_1.default.findOne({ name: "Invoice1" });
+        (0, globals_1.expect)(table).toBe(null);
     });
-    it("ignores a col on duplicate col nm", async () => {
+    (0, globals_1.it)("ignores a col on duplicate col nm", async () => {
         const csv = `item,cost,cost, vatable
 Book, 5,4, f
 Pencil, 0.5,2, t`;
         const fnm = "/tmp/test2.csv";
-        await fs.writeFile(fnm, csv);
-        const res = await Table.create_from_csv("Invoice1", fnm);
-        expect(res.table.fields.length).toEqual(4); //and id
+        await (0, promises_1.writeFile)(fnm, csv);
+        const res = await table_1.default.create_from_csv("Invoice1", fnm);
+        (0, assertions_1.assertsIsSuccessMessage)(res);
+        (0, globals_1.expect)(res.table.fields.length).toEqual(4); //and id
     });
-    it("should fail non-int id", async () => {
+    (0, globals_1.it)("should fail non-int id", async () => {
         const csv = `id,cost,!, vatable
 Book, 5,4, f
 Pencil, 0.5,2, t`;
         const fnm = "/tmp/test2.csv";
-        await fs.writeFile(fnm, csv);
-        const res = await Table.create_from_csv("Invoice2", fnm);
-        expect(res).toEqual({
+        await (0, promises_1.writeFile)(fnm, csv);
+        const res = await table_1.default.create_from_csv("Invoice2", fnm);
+        (0, globals_1.expect)(res).toEqual({
             error: `Columns named "id" must have only integers`,
         });
-        const table = await Table.findOne({ name: "Invoice2" });
-        expect(table).toBe(null);
+        const table = await table_1.default.findOne({ name: "Invoice2" });
+        (0, globals_1.expect)(table).toBe(null);
     });
-    it("should fail missing id", async () => {
+    (0, globals_1.it)("should fail missing id", async () => {
         const csv = `id,cost,!, vatable
 1, 5,4, f
 , 0.5,2, t`;
         const fnm = "/tmp/test2.csv";
-        await fs.writeFile(fnm, csv);
-        const res = await Table.create_from_csv("Invoice3", fnm);
-        expect(res).toEqual({
+        await (0, promises_1.writeFile)(fnm, csv);
+        const res = await table_1.default.create_from_csv("Invoice3", fnm);
+        (0, globals_1.expect)(res).toEqual({
             error: `Columns named "id" must not have missing values`,
         });
-        const table = await Table.findOne({ name: "Invoice3" });
-        expect(table).toBe(null);
+        const table = await table_1.default.findOne({ name: "Invoice3" });
+        (0, globals_1.expect)(table).toBe(null);
     });
-    it("should succeed on good id", async () => {
+    (0, globals_1.it)("should succeed on good id", async () => {
         const csv = `id,cost,count, vatable
 1, 5,4, f
 2, 0.5,2, t`;
         const fnm = "/tmp/test2.csv";
-        await fs.writeFile(fnm, csv);
-        const res = await Table.create_from_csv("Invoice3", fnm);
-        expect(res.table.fields.length).toEqual(4); // incl id
-        const table = await Table.findOne({ name: "Invoice3" });
+        await (0, promises_1.writeFile)(fnm, csv);
+        const res = await table_1.default.create_from_csv("Invoice3", fnm);
+        (0, assertions_1.assertsIsSuccessMessage)(res);
+        (0, globals_1.expect)(res.table.fields.length).toEqual(4); // incl id
+        const table = await table_1.default.findOne({ name: "Invoice3" });
+        (0, assertions_1.assertIsSet)(table);
         const rows = await table.getRows();
-        expect(rows.length).toBe(2);
+        (0, globals_1.expect)(rows.length).toBe(2);
         await table.insertRow({ cost: 0.2, count: 1, vatable: true });
         const rows3 = await table.getRows();
-        expect(rows3.length).toBe(3);
+        (0, globals_1.expect)(rows3.length).toBe(3);
     });
-    it("should fail on repeat id", async () => {
+    (0, globals_1.it)("should fail on repeat id", async () => {
         const csv = `id,cost,count, vatable
 1, 5,4, f
 1, 0.5,2, t`;
         const fnm = "/tmp/test2.csv";
-        await fs.writeFile(fnm, csv);
-        const res = await Table.create_from_csv("Invoice4", fnm);
-        expect(res.error).toContain("Invoice4");
-        const table = await Table.findOne({ name: "Invoice4" });
-        expect(table).toBe(null);
-    });
-    it("should import with missing", async () => {
+        await (0, promises_1.writeFile)(fnm, csv);
+        const res = await table_1.default.create_from_csv("Invoice4", fnm);
+        (0, assertions_1.assertIsErrorMsg)(res);
+        (0, globals_1.expect)(res.error).toContain("Invoice4");
+        const table = await table_1.default.findOne({ name: "Invoice4" });
+        (0, globals_1.expect)(table).toBe(null);
+    });
+    (0, globals_1.it)("should import with missing", async () => {
         const csv = `item,cost,count, vatable
 Book, 5,4, f
 Pencil, 0.5,, t`;
         const fnm = "/tmp/test2.csv";
-        await fs.writeFile(fnm, csv);
-        const { table, error } = await Table.create_from_csv("InvoiceMissing", fnm);
-        expect(error).toBe(undefined);
-        expect(!!table).toBe(true);
+        await (0, promises_1.writeFile)(fnm, csv);
+        const result = await table_1.default.create_from_csv("InvoiceMissing", fnm);
+        (0, assertions_1.assertsIsSuccessMessage)(result);
+        const { table } = result;
+        (0, assertions_1.assertIsSet)(table);
+        (0, globals_1.expect)(!!table).toBe(true);
         const fields = await table.getFields();
         const countField = fields.find((f) => f.name === "count");
-        expect(countField.type.name).toBe("Integer");
-        expect(countField.required).toBe(false);
+        (0, assertions_1.assertIsSet)(countField);
+        (0, assertions_1.assertIsType)(countField.type);
+        (0, globals_1.expect)(countField.type.name).toBe("Integer");
+        (0, globals_1.expect)(countField.required).toBe(false);
         const rows = await table.getRows({ item: "Pencil" });
-        expect(rows.length).toBe(1);
-        expect(rows[0].count).toBe(null);
+        (0, globals_1.expect)(rows.length).toBe(1);
+        (0, globals_1.expect)(rows[0].count).toBe(null);
         const brows = await table.getRows({ item: "Book" });
-        expect(brows[0].count).toBe(4);
+        (0, globals_1.expect)(brows[0].count).toBe(4);
     });
-    it("should import with space in name", async () => {
+    (0, globals_1.it)("should import with space in name", async () => {
         //db.set_sql_logging();
         const csv = `Item Name,cost,count, vatable
 Book, 5,4, f
 Pencil, 0.5,2, t`;
         const fnm = "/tmp/test2impok.csv";
-        await fs.writeFile(fnm, csv);
-        const { table } = await Table.create_from_csv("Invoice5", fnm);
+        await (0, promises_1.writeFile)(fnm, csv);
+        const result = await table_1.default.create_from_csv("Invoice5", fnm);
+        (0, assertions_1.assertsIsSuccessMessage)(result);
+        const { table } = result;
         const fields = await table.getFields();
         const nameField = fields.find((f) => f.name === "item_name");
-        expect(nameField.type.name).toBe("String");
-        expect(nameField.label).toBe("Item Name");
+        (0, globals_1.expect)(nameField.type.name).toBe("String");
+        (0, globals_1.expect)(nameField.label).toBe("Item Name");
         const allrows = await table.getRows();
-        expect(allrows.length).toBe(2);
+        (0, globals_1.expect)(allrows.length).toBe(2);
     });
-    it("should import with underscore in name", async () => {
+    (0, globals_1.it)("should import with underscore in name", async () => {
         //db.set_sql_logging();
         const csv = `Item_Name,cost,count, vatable
 Book, 5,4, f
 Pencil, 0.5,2, t`;
         const fnm = "/tmp/test2impok.csv";
-        await fs.writeFile(fnm, csv);
-        const { table } = await Table.create_from_csv("Invoice6", fnm);
+        await (0, promises_1.writeFile)(fnm, csv);
+        const result = await table_1.default.create_from_csv("Invoice6", fnm);
+        (0, assertions_1.assertsIsSuccessMessage)(result);
+        const { table } = result;
         const fields = await table.getFields();
-        expect(fields.map((f) => f.name)).toContain("item_name");
+        (0, globals_1.expect)(fields.map((f) => f.name)).toContain("item_name");
         const nameField = fields.find((f) => f.name === "item_name");
-        expect(nameField.type.name).toBe("String");
-        expect(nameField.label).toBe("Item Name");
+        (0, globals_1.expect)(nameField.type.name).toBe("String");
+        (0, globals_1.expect)(nameField.label).toBe("Item Name");
         const allrows = await table.getRows();
-        expect(allrows.length).toBe(2);
+        (0, globals_1.expect)(allrows.length).toBe(2);
     });
 });
-describe("Table field uppercase", () => {
-    it("should create by importing", async () => {
+(0, globals_1.describe)("Table field uppercase", () => {
+    (0, globals_1.it)("should create by importing", async () => {
         const csv = `Item,cost,Count,Vatable
 Book, 5,4, f
 Pencil, 0.5,2, t`;
         const fnm = "/tmp/test_uc.csv";
-        await fs.writeFile(fnm, csv);
-        const { table } = await Table.create_from_csv("InvoiceUC", fnm);
+        await (0, promises_1.writeFile)(fnm, csv);
+        const result = await table_1.default.create_from_csv("InvoiceUC", fnm);
+        (0, assertions_1.assertsIsSuccessMessage)(result);
+        const { table } = result;
+        (0, assertions_1.assertIsSet)(table);
         const fields = await table.getFields();
         const rows1 = await table.getJoinedRows({
             where: { item: { ilike: "East" } },
         });
-        expect(rows1.length).toBe(0);
+        (0, globals_1.expect)(rows1.length).toBe(0);
         const rows2 = await table.getJoinedRows({
             where: { count: 2 },
         });
-        expect(rows2.length).toBe(1);
+        (0, globals_1.expect)(rows2.length).toBe(1);
         const rows3 = await table.getJoinedRows({
             where: { _fts: { searchTerm: "Book", fields } },
         });
-        expect(rows3.length).toBe(1);
+        (0, globals_1.expect)(rows3.length).toBe(1);
     });
 });
-describe("Table unique constraint", () => {
-    it("should create table", async () => {
+(0, globals_1.describe)("Table unique constraint", () => {
+    (0, globals_1.it)("should create table", async () => {
         //db.set_sql_logging()
-        const table = await Table.create("TableWithUniques");
-        const field = await Field.create({
+        const table = await table_1.default.create("TableWithUniques");
+        const field = await field_1.default.create({
             table,
             name: "name",
             type: "String",
@@ -665,38 +735,40 @@ describe("Table unique constraint", () => {
         await table.insertRow({ name: "Bill" });
         const ted_id = await table.insertRow({ name: "Ted" });
         const ins_res = await table.tryInsertRow({ name: "Bill" });
-        expect(ins_res).toEqual({
+        (0, globals_1.expect)(ins_res).toEqual({
             error: "Duplicate value for unique field: name",
         });
         const ins_res1 = await table.tryInsertRow({ name: "Billy" });
-        expect(typeof ins_res1.success).toEqual("number");
+        (0, assertions_1.assertsIsSuccessMessage)(ins_res1);
+        (0, globals_1.expect)(typeof ins_res1.success).toEqual("number");
         const upd_res = await table.tryUpdateRow({ name: "Bill" }, ted_id);
-        expect(upd_res).toEqual({
+        (0, globals_1.expect)(upd_res).toEqual({
             error: "Duplicate value for unique field: name",
         });
         const upd_res1 = await table.tryUpdateRow({ name: "teddy" }, ted_id);
-        expect(upd_res1.success).toEqual(true);
+        (0, assertions_1.assertsIsSuccessMessage)(upd_res1);
+        (0, globals_1.expect)(upd_res1.success).toEqual(true);
         await field.update({ is_unique: false });
-        const field1 = await Field.findOne({ id: field.id });
-        expect(field1.is_unique).toBe(false);
+        const field1 = await field_1.default.findOne({ id: field.id });
+        (0, globals_1.expect)(field1.is_unique).toBe(false);
         //const bill2_id = await table.insertRow({ name: "Bill" });
         await field1.update({ is_unique: true });
-        const field2 = await Field.findOne({ id: field.id });
-        expect(field2.is_unique).toBe(true);
-        expect(field1.is_unique).toBe(true);
+        const field2 = await field_1.default.findOne({ id: field.id });
+        (0, globals_1.expect)(field2.is_unique).toBe(true);
+        (0, globals_1.expect)(field1.is_unique).toBe(true);
     });
 });
-describe("Table not null constraint", () => {
-    it("should create table", async () => {
+(0, globals_1.describe)("Table not null constraint", () => {
+    (0, globals_1.it)("should create table", async () => {
         //db.set_sql_logging()
-        const table = await Table.create("TableWithNotNulls");
-        const field = await Field.create({
+        const table = await table_1.default.create("TableWithNotNulls");
+        const field = await field_1.default.create({
             table,
             name: "name",
             type: "String",
             required: true,
         });
-        await Field.create({
+        await field_1.default.create({
             table,
             name: "age",
             type: "Integer",
@@ -704,70 +776,73 @@ describe("Table not null constraint", () => {
         await table.insertRow({ name: "Bill", age: 13 });
         await table.insertRow({ name: "Bill", age: 13 });
         const ins_res = await table.tryInsertRow({ age: 17, name: null });
-        expect(!!ins_res.error).toBe(true);
-        expect(ins_res.error).toContain("name");
-        if (!db.isSQLite) {
+        (0, assertions_1.assertIsErrorMsg)(ins_res);
+        (0, globals_1.expect)(!!ins_res.error).toBe(true);
+        (0, globals_1.expect)(ins_res.error).toContain("name");
+        if (!db_1.default.isSQLite) {
             await field.update({ required: false });
             const ted_id = await table.insertRow({ age: 17 });
             await table.deleteRows({ id: ted_id });
             await field.update({ required: true });
             const ins_res1 = await table.tryInsertRow({ age: 167 });
-            expect(!!ins_res1.error).toBe(true);
+            (0, assertions_1.assertIsErrorMsg)(ins_res1);
+            (0, globals_1.expect)(!!ins_res1.error).toBe(true);
         }
     });
-    it("should query null", async () => {
-        const table = await Table.findOne({ name: "TableWithNotNulls" });
+    (0, globals_1.it)("should query null", async () => {
+        const table = await table_1.default.findOne({ name: "TableWithNotNulls" });
+        (0, assertions_1.assertIsSet)(table);
         await table.insertRow({ name: "Ageless", age: null });
         const rows = await table.getRows({ age: null });
-        expect(rows.length).toBe(1);
-        expect(rows[0].name).toBe("Ageless");
+        (0, globals_1.expect)(rows.length).toBe(1);
+        (0, globals_1.expect)(rows[0].name).toBe("Ageless");
         const rows1 = await table.getRows({ age: null, name: "Ageless" });
-        expect(rows1.length).toBe(1);
-        expect(rows1[0].name).toBe("Ageless");
+        (0, globals_1.expect)(rows1.length).toBe(1);
+        (0, globals_1.expect)(rows1[0].name).toBe("Ageless");
         const rows2 = await table.getRows({ name: "Ageless", age: null });
-        expect(rows2.length).toBe(1);
-        expect(rows2[0].name).toBe("Ageless");
+        (0, globals_1.expect)(rows2.length).toBe(1);
+        (0, globals_1.expect)(rows2[0].name).toBe("Ageless");
     });
 });
-describe("Table with users and files", () => {
-    it("should create table", async () => {
+(0, globals_1.describe)("Table with users and files", () => {
+    (0, globals_1.it)("should create table", async () => {
         //db.set_sql_logging()
         const rick = await rick_file();
-        const table = await Table.create("TableWithUsers");
-        await Field.create({
+        const table = await table_1.default.create("TableWithUsers");
+        await field_1.default.create({
             table,
             name: "name",
             type: "String",
             is_unique: true,
         });
-        await Field.create({
+        await field_1.default.create({
             table,
             name: "owner",
             type: "Key to users",
         });
-        await Field.create({
+        await field_1.default.create({
             table,
             name: "mugshot",
             type: "File",
         });
         await table.insertRow({ name: "Rocket", owner: 1, mugshot: rick.id });
         const rels = await table.get_parent_relations();
-        expect(rels.parent_field_list).toEqual(["owner.email", "owner.id"]);
+        (0, globals_1.expect)(rels.parent_field_list).toEqual(["owner.email", "owner.id"]);
         const joined = await table.getJoinedRows();
         // expect(joined).toEqual("rick.png")
-        expect(joined[0].mugshot__filename).toEqual("rick.png");
+        (0, globals_1.expect)(joined[0].mugshot__filename).toEqual("rick.png");
     });
 });
-describe("Table and view deletion ", () => {
-    it("should setup", async () => {
-        const tc = await Table.create("mytable19");
-        await Field.create({
+(0, globals_1.describe)("Table and view deletion ", () => {
+    (0, globals_1.it)("should setup", async () => {
+        const tc = await table_1.default.create("mytable19");
+        await field_1.default.create({
             table: tc,
             name: "name",
             type: "String",
             is_unique: true,
         });
-        const v = await View.create({
+        const v = await view_1.default.create({
             table_id: tc.id,
             name: "anewview",
             viewtemplate: "List",
@@ -784,17 +859,17 @@ describe("Table and view deletion ", () => {
         //expect(error).toBeInstanceOf(Error); - not on SQLite
         await v.delete();
     });
-    it("should delete table after view delete", async () => {
-        const tc = await Table.findOne({ name: "mytable19" });
+    (0, globals_1.it)("should delete table after view delete", async () => {
+        const tc = await table_1.default.findOne({ name: "mytable19" });
         if (tc)
             await tc.delete();
     });
 });
-describe("Table with date", () => {
-    it("should create table", async () => {
+(0, globals_1.describe)("Table with date", () => {
+    (0, globals_1.it)("should create table", async () => {
         //db.set_sql_logging()
-        const table = await Table.create("TableWithDates");
-        await Field.create({
+        const table = await table_1.default.create("TableWithDates");
+        await field_1.default.create({
             table,
             name: "time",
             type: "Date",
@@ -802,25 +877,25 @@ describe("Table with date", () => {
         await table.insertRow({ time: new Date() });
         const rows = await table.getRows();
         var dif = new Date(rows[0].time).getTime() - new Date().getTime();
-        expect(Math.abs(dif)).toBeLessThanOrEqual(1000);
+        (0, globals_1.expect)(Math.abs(dif)).toBeLessThanOrEqual(1000);
     });
 });
-describe("Tables with name clashes", () => {
-    it("should create tables", async () => {
+(0, globals_1.describe)("Tables with name clashes", () => {
+    (0, globals_1.it)("should create tables", async () => {
         //db.set_sql_logging()
-        const cars = await Table.create("TableClashCar");
-        const persons = await Table.create("TableClashPerson");
-        await Field.create({
+        const cars = await table_1.default.create("TableClashCar");
+        const persons = await table_1.default.create("TableClashPerson");
+        await field_1.default.create({
             table: persons,
             name: "name",
             type: "String",
         });
-        await Field.create({
+        await field_1.default.create({
             table: cars,
             name: "name",
             type: "String",
         });
-        await Field.create({
+        await field_1.default.create({
             table: cars,
             name: "owner",
             type: "Key to TableClashPerson",
@@ -828,23 +903,25 @@ describe("Tables with name clashes", () => {
         const sally = await persons.insertRow({ name: "Sally" });
         await cars.insertRow({ name: "Mustang", owner: sally });
     });
-    it("should query", async () => {
-        const cars = await Table.findOne({ name: "TableClashCar" });
+    (0, globals_1.it)("should query", async () => {
+        const cars = await table_1.default.findOne({ name: "TableClashCar" });
+        (0, assertions_1.assertIsSet)(cars);
         const rows = await cars.getJoinedRows({
             joinFields: {
                 owner_name: { ref: "owner", target: "name" },
             },
         });
-        expect(rows[0]).toEqual({
+        (0, globals_1.expect)(rows[0]).toEqual({
             id: 1,
             name: "Mustang",
             owner: 1,
             owner_name: "Sally",
         });
     });
-    it("should show list view", async () => {
-        const cars = await Table.findOne({ name: "TableClashCar" });
-        const v = await View.create({
+    (0, globals_1.it)("should show list view", async () => {
+        const cars = await table_1.default.findOne({ name: "TableClashCar" });
+        (0, assertions_1.assertIsSet)(cars);
+        const v = await view_1.default.create({
             table_id: cars.id,
             name: "patientlist",
             viewtemplate: "List",
@@ -857,12 +934,13 @@ describe("Tables with name clashes", () => {
             min_role: 10,
         });
         const res = await v.run({}, mockReqRes);
-        expect(res).toContain("Mustang");
-        expect(res).toContain("Sally");
+        (0, globals_1.expect)(res).toContain("Mustang");
+        (0, globals_1.expect)(res).toContain("Sally");
     });
-    it("should show show view", async () => {
-        const cars = await Table.findOne({ name: "TableClashCar" });
-        const v = await View.create({
+    (0, globals_1.it)("should show show view", async () => {
+        const cars = await table_1.default.findOne({ name: "TableClashCar" });
+        (0, assertions_1.assertIsSet)(cars);
+        const v = await view_1.default.create({
             table_id: cars.id,
             name: "patientlist",
             viewtemplate: "Show",
@@ -881,115 +959,123 @@ describe("Tables with name clashes", () => {
             min_role: 10,
         });
         const res = await v.run({ id: 1 }, mockReqRes);
-        expect(res).toContain("Mustang");
-        expect(res).toContain("Sally");
+        (0, globals_1.expect)(res).toContain("Mustang");
+        (0, globals_1.expect)(res).toContain("Sally");
     });
 });
-describe("Table joint unique constraint", () => {
-    it("should create table", async () => {
-        const table = await Table.findOne({ name: "books" });
+(0, globals_1.describe)("Table joint unique constraint", () => {
+    (0, globals_1.it)("should create table", async () => {
+        const table = await table_1.default.findOne({ name: "books" });
+        (0, assertions_1.assertIsSet)(table);
+        (0, assertions_1.assertIsSet)(table.id);
         const rows = await table.getRows();
         const { id, ...row0 } = rows[0];
-        const tc = await TableConstraint.create({
+        const tc = await table_constraints_1.default.create({
             table_id: table.id,
             type: "Unique",
             configuration: { fields: ["author", "pages"] },
         });
         const res = await table.tryInsertRow(row0);
-        expect(!!res.error).toBe(true);
+        (0, assertions_1.assertIsErrorMsg)(res);
+        (0, globals_1.expect)(!!res.error).toBe(true);
         await tc.delete();
         const res1 = await table.tryInsertRow(row0);
-        expect(!!res1.error).toBe(false);
+        (0, assertions_1.assertIsErrorMsg)(res1);
+        (0, globals_1.expect)(!!res1.error).toBe(false);
     });
 });
-describe("Table with row ownership", () => {
-    it("should create and delete table", async () => {
-        const persons = await Table.create("TableOwned");
-        const name = await Field.create({
+(0, globals_1.describe)("Table with row ownership", () => {
+    (0, globals_1.it)("should create and delete table", async () => {
+        const persons = await table_1.default.create("TableOwned");
+        const name = await field_1.default.create({
             table: persons,
             name: "name",
             type: "String",
         });
-        const age = await Field.create({
+        const age = await field_1.default.create({
             table: persons,
             name: "age",
             type: "String",
         });
-        const owner = await Field.create({
+        const owner = await field_1.default.create({
             table: persons,
             name: "owner",
             type: "Key to users",
         });
         await persons.update({ ownership_field_id: owner.id });
-        if (!db.isSQLite) {
+        if (!db_1.default.isSQLite) {
             await age.update({ type: "Integer" });
             await name.update({ name: "lastname" });
             await persons.insertRow({ lastname: "Joe", age: 12 });
             await persons.insertRow({ lastname: "Sam", age: 13, owner: 1 });
             const row = await persons.getRow({ age: 12 });
-            expect(row.lastname).toBe("Joe");
-            expect(row.age).toBe(12);
+            (0, assertions_1.assertIsSet)(row);
+            (0, globals_1.expect)(row.lastname).toBe("Joe");
+            (0, globals_1.expect)(row.age).toBe(12);
             const owner_fnm = await persons.owner_fieldname();
-            expect(owner_fnm).toBe("owner");
+            (0, globals_1.expect)(owner_fnm).toBe("owner");
             const is_owner = await persons.is_owner({ id: 6 }, row);
-            expect(is_owner).toBe(false);
+            (0, globals_1.expect)(is_owner).toBe(false);
             const row1 = await persons.getRow({ age: 13 });
+            (0, assertions_1.assertIsSet)(row1);
             const is_owner1 = await persons.is_owner({ id: 1 }, row1);
-            expect(is_owner1).toBe(true);
+            (0, globals_1.expect)(is_owner1).toBe(true);
         }
         await persons.delete();
     });
 });
-describe("Table with row ownership", () => {
-    it("should create and delete table", async () => {
-        const persons = await Table.create("TableOwnedFml");
-        const name = await Field.create({
+(0, globals_1.describe)("Table with row ownership", () => {
+    (0, globals_1.it)("should create and delete table", async () => {
+        const persons = await table_1.default.create("TableOwnedFml");
+        const name = await field_1.default.create({
             table: persons,
             name: "name",
             type: "String",
         });
-        const age = await Field.create({
+        const age = await field_1.default.create({
             table: persons,
             name: "age",
             type: "String",
         });
-        const owner = await Field.create({
+        const owner = await field_1.default.create({
             table: persons,
             name: "owner",
             type: "Key to users",
         });
         await persons.update({ ownership_formula: "user.id===owner" });
-        if (!db.isSQLite) {
+        if (!db_1.default.isSQLite) {
             await age.update({ type: "Integer" });
             await name.update({ name: "lastname" });
             await persons.insertRow({ lastname: "Joe", age: 12 });
             await persons.insertRow({ lastname: "Sam", age: 13, owner: 1 });
             const row = await persons.getRow({ age: 12 });
-            expect(row.lastname).toBe("Joe");
-            expect(row.age).toBe(12);
+            (0, assertions_1.assertIsSet)(row);
+            (0, globals_1.expect)(row.lastname).toBe("Joe");
+            (0, globals_1.expect)(row.age).toBe(12);
             const is_owner = await persons.is_owner({ id: 6 }, row);
-            expect(is_owner).toBe(false);
+            (0, globals_1.expect)(is_owner).toBe(false);
             const row1 = await persons.getRow({ age: 13 });
+            (0, assertions_1.assertIsSet)(row1);
             const is_owner1 = await persons.is_owner({ id: 1 }, row1);
-            expect(is_owner1).toBe(true);
+            (0, globals_1.expect)(is_owner1).toBe(true);
         }
         await persons.delete();
     });
 });
-describe("Table with UUID pks", () => {
-    if (!db.isSQLite) {
-        it("should select uuid", async () => {
-            await db.query('create extension if not exists "uuid-ossp";');
-            const { rows } = await db.query("select uuid_generate_v4();");
-            expect(rows.length).toBe(1);
-            expect(typeof rows[0].uuid_generate_v4).toBe("string");
-        });
-        it("should create and insert stuff in table", async () => {
+(0, globals_1.describe)("Table with UUID pks", () => {
+    if (!db_1.default.isSQLite) {
+        (0, globals_1.it)("should select uuid", async () => {
+            await db_1.default.query('create extension if not exists "uuid-ossp";');
+            const { rows } = await db_1.default.query("select uuid_generate_v4();");
+            (0, globals_1.expect)(rows.length).toBe(1);
+            (0, globals_1.expect)(typeof rows[0].uuid_generate_v4).toBe("string");
+        });
+        (0, globals_1.it)("should create and insert stuff in table", async () => {
             getState().registerPlugin("mock_plugin", plugin_with_routes);
-            const table = await Table.create("TableUUID");
+            const table = await table_1.default.create("TableUUID");
             const [pk] = await table.getFields();
             await pk.update({ type: "UUID" });
-            const name = await Field.create({
+            const name = await field_1.default.create({
                 table: table,
                 name: "name",
                 type: "String",
@@ -997,44 +1083,47 @@ describe("Table with UUID pks", () => {
             table.fields = null;
             await table.insertRow({ name: "Sam" });
             const rows = await table.getRows();
-            expect(rows.length).toBe(1);
-            expect(typeof rows[0].id).toBe("string");
-            expect(rows[0].id.length > 10).toBe(true);
-            expect(rows[0].name).toBe("Sam");
+            (0, globals_1.expect)(rows.length).toBe(1);
+            (0, globals_1.expect)(typeof rows[0].id).toBe("string");
+            (0, globals_1.expect)(rows[0].id.length > 10).toBe(true);
+            (0, globals_1.expect)(rows[0].name).toBe("Sam");
             await table.updateRow({ name: "Jim" }, rows[0].id);
             const rows1 = await table.getJoinedRows();
-            expect(rows1.length).toBe(1);
-            expect(typeof rows1[0].id).toBe("string");
-            expect(rows1[0].id).toBe(rows[0].id);
-            expect(rows1[0].name).toBe("Jim");
+            (0, globals_1.expect)(rows1.length).toBe(1);
+            (0, globals_1.expect)(typeof rows1[0].id).toBe("string");
+            (0, globals_1.expect)(rows1[0].id).toBe(rows[0].id);
+            (0, globals_1.expect)(rows1[0].name).toBe("Jim");
             const row = await table.getRow({ id: rows[0].id });
-            expect(row.name).toBe("Jim");
+            (0, assertions_1.assertIsSet)(row);
+            (0, globals_1.expect)(row.name).toBe("Jim");
         });
-        it("should import json", async () => {
+        (0, globals_1.it)("should import json", async () => {
             const json = [
                 { name: "Alex", id: "750d07fc-943d-4afc-9084-3911bcdbd0f7" },
             ];
             const fnm = "/tmp/test1.json";
-            await fs.writeFile(fnm, JSON.stringify(json));
-            const table = await Table.findOne({ name: "TableUUID" });
-            expect(!!table).toBe(true);
+            await (0, promises_1.writeFile)(fnm, JSON.stringify(json));
+            const table = await table_1.default.findOne({ name: "TableUUID" });
+            (0, assertions_1.assertIsSet)(table);
+            (0, globals_1.expect)(!!table).toBe(true);
             const impres = await table.import_json_file(fnm);
-            expect(impres).toEqual({
+            (0, globals_1.expect)(impres).toEqual({
                 success: "Imported 1 rows into table TableUUID",
             });
             const rows = await table.getRows();
-            expect(rows.length).toBe(2);
+            (0, globals_1.expect)(rows.length).toBe(2);
         });
-        it("should be joinable to", async () => {
-            const uuidtable1 = await Table.findOne({ name: "TableUUID" });
-            const table = await Table.create("JoinUUID");
-            await Field.create({
+        (0, globals_1.it)("should be joinable to", async () => {
+            const uuidtable1 = await table_1.default.findOne({ name: "TableUUID" });
+            (0, assertions_1.assertIsSet)(uuidtable1);
+            const table = await table_1.default.create("JoinUUID");
+            await field_1.default.create({
                 table: table,
                 name: "myname",
                 type: "String",
             });
             //db.set_sql_logging();
-            await Field.create({
+            await field_1.default.create({
                 table: table,
                 name: "follows",
                 type: "Key to TableUUID",
@@ -1052,15 +1141,15 @@ describe("Table with UUID pks", () => {
                 const allRows = await table.getRows();
                 console.log(allRows);
             }
-            expect(rows.length).toBe(1);
-            expect(rows[0].leader).toBe("Jim");
-            expect(rows[0].myname).toBe("Fred");
+            (0, globals_1.expect)(rows.length).toBe(1);
+            (0, globals_1.expect)(rows[0].leader).toBe("Jim");
+            (0, globals_1.expect)(rows[0].myname).toBe("Fred");
             await table.delete();
             await uuidtable1.delete();
         });
-        it("should create and delete table", async () => {
+        (0, globals_1.it)("should create and delete table", async () => {
             getState().registerPlugin("mock_plugin", plugin_with_routes);
-            const table = await Table.create("TableUUID1");
+            const table = await table_1.default.create("TableUUID1");
             const [pk] = await table.getFields();
             await pk.update({ type: "UUID" });
             table.fields = null;
@@ -1070,41 +1159,41 @@ describe("Table with UUID pks", () => {
         });
     }
 });
-describe("external tables", () => {
-    it("should register plugin", async () => {
+(0, globals_1.describe)("external tables", () => {
+    (0, globals_1.it)("should register plugin", async () => {
         getState().registerPlugin("mock_plugin", plugin_with_routes);
     });
-    it("should find table", async () => {
-        const table = await Table.findOne({ name: "exttab" });
-        expect(!!table).toBe(true);
-        const notable = await Table.findOne({ name: "exttnosuchab" });
-        expect(!!notable).toBe(false);
-        const tables = await Table.find_with_external();
-        expect(tables.map((t) => t.name)).toContain("exttab");
-        expect(tables.map((t) => t.name)).toContain("books");
-        const etables = await Table.find_with_external({ external: true });
-        expect(etables.map((t) => t.name)).toEqual(["exttab"]);
-        const dbtables = await Table.find_with_external({ external: false });
-        expect(dbtables.map((t) => t.name)).not.toContain("exttab");
-        expect(dbtables.map((t) => t.name)).toContain("books");
+    (0, globals_1.it)("should find table", async () => {
+        const table = await table_1.default.findOne({ name: "exttab" });
+        (0, globals_1.expect)(!!table).toBe(true);
+        const notable = await table_1.default.findOne({ name: "exttnosuchab" });
+        (0, globals_1.expect)(!!notable).toBe(false);
+        const tables = await table_1.default.find_with_external();
+        (0, globals_1.expect)(tables.map((t) => t.name)).toContain("exttab");
+        (0, globals_1.expect)(tables.map((t) => t.name)).toContain("books");
+        const etables = await table_1.default.find_with_external({ external: true });
+        (0, globals_1.expect)(etables.map((t) => t.name)).toEqual(["exttab"]);
+        const dbtables = await table_1.default.find_with_external({ external: false });
+        (0, globals_1.expect)(dbtables.map((t) => t.name)).not.toContain("exttab");
+        (0, globals_1.expect)(dbtables.map((t) => t.name)).toContain("books");
     });
 });
-describe("distance ordering", () => {
-    it("should create table", async () => {
-        const tc = await Table.create("geotable1");
-        await Field.create({
+(0, globals_1.describe)("distance ordering", () => {
+    (0, globals_1.it)("should create table", async () => {
+        const tc = await table_1.default.create("geotable1");
+        await field_1.default.create({
             table: tc,
             label: "Name",
             type: "String",
             required: true,
         });
-        await Field.create({
+        await field_1.default.create({
             table: tc,
             label: "Lat",
             type: "Float",
             required: true,
         });
-        await Field.create({
+        await field_1.default.create({
             table: tc,
             label: "Long",
             type: "Float",
@@ -1113,22 +1202,23 @@ describe("distance ordering", () => {
         await tc.insertRow({ name: "Fred", lat: 10, long: 10 });
         await tc.insertRow({ name: "George", lat: 20, long: 20 });
     });
-    it("should query", async () => {
-        const table = await Table.findOne({ name: "geotable1" });
+    (0, globals_1.it)("should query", async () => {
+        const table = await table_1.default.findOne({ name: "geotable1" });
+        (0, assertions_1.assertIsSet)(table);
         const fred_rows = await table.getRows({}, {
             orderBy: {
                 distance: { lat: 11, long: 11, latField: "lat", longField: "long" },
             },
         });
-        expect(fred_rows.length).toBe(2);
-        expect(fred_rows[0].name).toBe("Fred");
+        (0, globals_1.expect)(fred_rows.length).toBe(2);
+        (0, globals_1.expect)(fred_rows[0].name).toBe("Fred");
         const george_rows = await table.getJoinedRows({
             orderBy: {
                 distance: { lat: 19, long: 19, latField: "lat", longField: "long" },
             },
         });
-        expect(george_rows.length).toBe(2);
-        expect(george_rows[0].name).toBe("George");
+        (0, globals_1.expect)(george_rows.length).toBe(2);
+        (0, globals_1.expect)(george_rows[0].name).toBe("George");
     });
 });
 //# sourceMappingURL=table.test.js.map