@saltcorn/data 0.6.1 → 0.6.2-beta.3

package/dist/tests/table.test.js

@@ -0,0 +1,1048 @@
+"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");
+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 () => {
+    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({
+            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 fields = await tc.getFields();
+        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({
+            table: tc,
+            label: "Group",
+            type: "Bool",
+            required: true,
+        });
+        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);
+    });
+    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({
+            table: mytable1,
+            name: "height1",
+            label: "height1",
+            type: "Integer",
+            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" });
+        const vs = await table.distinctValues("height1");
+        expect(vs).toEqual([7]);
+    });
+    it("should delete", async () => {
+        const table = await Table.findOne({ name: "mytable1" });
+        await table.delete();
+        const table1 = await Table.find({ name: "mytable1" });
+        expect(table1.length).toBe(0);
+    });
+});
+describe("Table get data", () => {
+    it("should get rows", async () => {
+        const patients = await Table.findOne({ name: "patients" });
+        const all = await patients.getRows();
+        expect(all.length).toStrictEqual(2);
+    });
+    it("should get rows where name is Michael", async () => {
+        const patients = await Table.findOne({ name: "patients" });
+        const michaels = await patients.getRows({ name: "Michael Douglas" });
+        expect(michaels.length).toStrictEqual(1);
+    });
+    it("should get limited rows", async () => {
+        const patients = await Table.findOne({ name: "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");
+    });
+    it("should get joined rows where name is Michael", async () => {
+        const patients = await Table.findOne({ name: "patients" });
+        const michaels = await patients.getJoinedRows({
+            where: { name: "Michael Douglas" },
+        });
+        expect(michaels.length).toStrictEqual(1);
+        expect(michaels[0].favbook).toBe(2);
+    });
+    it("should get rows in id range", async () => {
+        const patients = await Table.findOne({ name: "patients" });
+        const rows = await patients.getRows({ id: [{ gt: 0 }, { lt: 10 }] });
+        expect(rows.length).toStrictEqual(2);
+    });
+    it("should get rows by subselect", async () => {
+        const books = await Table.findOne({ name: "books" });
+        const nrows = await books.countRows({
+            id: {
+                inSelect: {
+                    table: "patients",
+                    field: "favbook",
+                    where: { author: "Leo Tolstoy" },
+                },
+            },
+        });
+        expect(nrows).toStrictEqual(1);
+    });
+    it("should get joined rows with limit and order", async () => {
+        const patients = await Table.findOne({ name: "patients" });
+        const all = await patients.getJoinedRows({
+            limit: 2,
+            orderBy: "id",
+        });
+        expect(all.length).toStrictEqual(2);
+        expect(all[1].favbook).toBe(2);
+    });
+    it("should get joined rows with limit and desc order", async () => {
+        const patients = await Table.findOne({ name: "patients" });
+        const all = await patients.getJoinedRows({
+            limit: 2,
+            orderBy: "id",
+            orderDesc: true,
+        });
+        expect(all.length).toStrictEqual(2);
+        expect(all[0].favbook).toBe(2);
+    });
+    it("should get joined rows with aggregations", async () => {
+        const patients = await Table.findOne({ name: "patients" });
+        const michaels = await patients.getJoinedRows({
+            orderBy: "id",
+            aggregations: {
+                avg_temp: {
+                    table: "readings",
+                    ref: "patient_id",
+                    field: "temperature",
+                    aggregate: "avg",
+                },
+            },
+        });
+        expect(michaels.length).toStrictEqual(2);
+        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" });
+        const michaels = await patients.getJoinedRows({
+            orderBy: "id",
+            aggregations: {
+                last_temp: {
+                    table: "readings",
+                    ref: "patient_id",
+                    field: "temperature",
+                    aggregate: "Latest date",
+                },
+            },
+        });
+        expect(michaels.length).toStrictEqual(2);
+        expect(Math.round(michaels[0].last_temp)).toBe(37);
+    });
+    it("should get double joined rows", async () => {
+        const readings = await Table.findOne({ name: "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");
+    });
+    it("should get joined rows with aggregations and joins", async () => {
+        const patients = await Table.findOne({ name: "patients" });
+        const michaels = await patients.getJoinedRows({
+            orderBy: "id",
+            aggregations: {
+                avg_temp: {
+                    table: "readings",
+                    ref: "patient_id",
+                    field: "temperature",
+                    aggregate: "avg",
+                },
+            },
+            joinFields: {
+                pages: { ref: "favbook", target: "pages" },
+                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");
+    });
+    it("should support full text search", async () => {
+        const table = await Table.findOne({ name: "patients" });
+        const fields = await table.getFields();
+        const rows = await db.select("patients", {
+            _fts: { fields, searchTerm: "Douglas" },
+        });
+        expect(rows.length).toBe(2);
+    });
+    it("should enable versioning", async () => {
+        const table = await Table.findOne({ name: "patients" });
+        table.versioned = true;
+        await table.update(table);
+    });
+    it("should save version on insert", async () => {
+        const table = await Table.findOne({ name: "patients" });
+        await table.insertRow({ name: "Bunny foo-foo", favbook: 1 });
+        const bunnyFooFoo = await table.getRow({ name: "Bunny foo-foo" });
+        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" });
+        const bunnyFooFoo = await table.getRow({ name: "Bunny foo-foo" });
+        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);
+        const goon = await table.getRow({ id: bunnyFooFoo.id });
+        expect(goon.name).toBe("Goon");
+        expect(goon.favbook).toBe(1);
+    });
+    it("create field on version table", async () => {
+        const table = await Table.findOne({ name: "patients" });
+        const fc = await Field.create({
+            table: table,
+            name: "Height19",
+            label: "height19",
+            type: "Integer",
+            required: true,
+            attributes: { default: 6 },
+        });
+        await fc.delete();
+    });
+    it("should disable versioning", async () => {
+        const table = await Table.findOne({ name: "patients" });
+        await table.getFields();
+        await table.update({ versioned: false });
+    });
+    it("should rename", async () => {
+        const table = await Table.create("notsurename");
+        await Field.create({
+            table,
+            label: "tall",
+            type: "Bool",
+            required: true,
+        });
+        const table1 = await Table.create("refsunsure");
+        await Field.create({
+            table: table1,
+            label: "also_tall",
+            type: "Bool",
+            required: true,
+        });
+        await Field.create({
+            table: table1,
+            label: "theref",
+            type: "Key to notsurename",
+            required: true,
+        });
+        const id = await table.insertRow({ tall: false });
+        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) {
+            await table.rename("isthisbetter");
+            const table3 = await Table.findOne({ name: "refsunsure" });
+            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);
+            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" });
+        const michaels = await patients.getJoinedRows({
+            where: { name: "Michael Douglas" },
+            joinFields: {
+                pages: { ref: "favbook", target: "pages" },
+                author: { ref: "favbook", target: "author" },
+            },
+        });
+        expect(michaels.length).toStrictEqual(1);
+        expect(michaels[0].pages).toBe(728);
+        expect(michaels[0].author).toBe("Leo Tolstoy");
+    });
+});
+describe("relations", () => {
+    it("get parent relations", async () => {
+        const table = await Table.findOne({ name: "patients" });
+        const rels = await table.get_parent_relations();
+        expect(rels.parent_field_list).toContain("favbook.author");
+        expect(rels.parent_relations.length).toBe(2);
+    });
+    it("get parent relations", async () => {
+        const table = await Table.findOne({ name: "books" });
+        const rels = await table.get_child_relations();
+        expect(rels.child_field_list).toEqual([
+            "discusses_books.book",
+            "patients.favbook",
+        ]);
+        expect(rels.child_relations.length).toBe(2);
+    });
+    it("get grandparent relations", async () => {
+        const table = await Table.findOne({ name: "readings" });
+        const rels = await table.get_parent_relations(true);
+        expect(rels.parent_field_list).toEqual([
+            "patient_id.favbook",
+            "patient_id.favbook.author",
+            "patient_id.favbook.id",
+            "patient_id.favbook.pages",
+            "patient_id.id",
+            "patient_id.name",
+            "patient_id.parent",
+            "patient_id.parent.favbook",
+            "patient_id.parent.id",
+            "patient_id.parent.name",
+            "patient_id.parent.parent",
+        ]);
+        expect(rels.parent_relations.length).toBe(3);
+    });
+});
+describe("CSV import", () => {
+    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);
+        const impres = await table.import_csv_file(fnm);
+        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);
+    });
+    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);
+        const impres = await table.import_csv_file(fnm);
+        expect(impres).toEqual({ error: "Required field missing: Pages" });
+    });
+    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", {
+            min_role_read: 10,
+        });
+        await Field.create({
+            table,
+            name: "author",
+            label: "Author",
+            type: "String",
+            required: true,
+        });
+        await Field.create({
+            table,
+            name: "pages",
+            label: "Pages",
+            type: "Integer",
+            attributes: { min: 0 },
+        });
+        expect(!!table).toBe(true);
+        const impres = await table.import_csv_file(fnm);
+        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);
+    });
+    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);
+        const fields = await table.getFields();
+        const vatField = fields.find((f) => f.name === "vatable");
+        expect(vatField.type.name).toBe("Bool");
+        const costField = fields.find((f) => f.name === "cost");
+        expect(costField.type.name).toBe("Float");
+        const countField = fields.find((f) => f.name === "count");
+        expect(countField.type.name).toBe("Integer");
+        const rows = await table.getRows({ item: "Pencil" });
+        expect(rows.length).toBe(1);
+        expect(rows[0].vatable).toBe(true);
+        const allrows = await table.getRows();
+        expect(allrows.length).toBe(2);
+    });
+    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({
+            error: "Invalid column name ! - Use A-Z, a-z, 0-9, _ only",
+        });
+        const table = await Table.findOne({ name: "Invoice1" });
+        expect(table).toBe(null);
+    });
+    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
+    });
+    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({
+            error: `Columns named "id" must have only integers`,
+        });
+        const table = await Table.findOne({ name: "Invoice2" });
+        expect(table).toBe(null);
+    });
+    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({
+            error: `Columns named "id" must not have missing values`,
+        });
+        const table = await Table.findOne({ name: "Invoice3" });
+        expect(table).toBe(null);
+    });
+    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" });
+        const rows = await table.getRows();
+        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);
+    });
+    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 () => {
+        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);
+        const fields = await table.getFields();
+        const countField = fields.find((f) => f.name === "count");
+        expect(countField.type.name).toBe("Integer");
+        expect(countField.required).toBe(false);
+        const rows = await table.getRows({ item: "Pencil" });
+        expect(rows.length).toBe(1);
+        expect(rows[0].count).toBe(null);
+        const brows = await table.getRows({ item: "Book" });
+        expect(brows[0].count).toBe(4);
+    });
+});
+describe("Table field uppercase", () => {
+    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);
+        const fields = await table.getFields();
+        const rows1 = await table.getJoinedRows({
+            where: { item: { ilike: "East" } },
+        });
+        expect(rows1.length).toBe(0);
+        const rows2 = await table.getJoinedRows({
+            where: { count: 2 },
+        });
+        expect(rows2.length).toBe(1);
+        const rows3 = await table.getJoinedRows({
+            where: { _fts: { searchTerm: "Book", fields } },
+        });
+        expect(rows3.length).toBe(1);
+    });
+});
+describe("Table unique constraint", () => {
+    it("should create table", async () => {
+        //db.set_sql_logging()
+        const table = await Table.create("TableWithUniques");
+        const field = await Field.create({
+            table,
+            name: "name",
+            type: "String",
+            is_unique: true,
+        });
+        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({
+            error: "Duplicate value for unique field: name",
+        });
+        const ins_res1 = await table.tryInsertRow({ name: "Billy" });
+        expect(typeof ins_res1.success).toEqual("number");
+        const upd_res = await table.tryUpdateRow({ name: "Bill" }, ted_id);
+        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);
+        await field.update({ is_unique: false });
+        const field1 = await Field.findOne({ id: field.id });
+        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);
+    });
+});
+describe("Table not null constraint", () => {
+    it("should create table", async () => {
+        //db.set_sql_logging()
+        const table = await Table.create("TableWithNotNulls");
+        const field = await Field.create({
+            table,
+            name: "name",
+            type: "String",
+            required: true,
+        });
+        await Field.create({
+            table,
+            name: "age",
+            type: "Integer",
+        });
+        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) {
+            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);
+        }
+    });
+    it("should query null", async () => {
+        const table = await Table.findOne({ name: "TableWithNotNulls" });
+        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");
+        const rows1 = await table.getRows({ age: null, name: "Ageless" });
+        expect(rows1.length).toBe(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");
+    });
+});
+describe("Table with users and files", () => {
+    it("should create table", async () => {
+        //db.set_sql_logging()
+        const rick = await rick_file();
+        const table = await Table.create("TableWithUsers");
+        await Field.create({
+            table,
+            name: "name",
+            type: "String",
+            is_unique: true,
+        });
+        await Field.create({
+            table,
+            name: "owner",
+            type: "Key to users",
+        });
+        await Field.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"]);
+        const joined = await table.getJoinedRows();
+        // expect(joined).toEqual("rick.png")
+        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({
+            table: tc,
+            name: "name",
+            type: "String",
+            is_unique: true,
+        });
+        const v = await View.create({
+            table_id: tc.id,
+            name: "anewview",
+            viewtemplate: "List",
+            configuration: { columns: [], default_state: {} },
+            min_role: 10,
+        });
+        let error;
+        try {
+            await tc.delete();
+        }
+        catch (e) {
+            error = e;
+        }
+        //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" });
+        if (tc)
+            await tc.delete();
+    });
+});
+describe("Table with date", () => {
+    it("should create table", async () => {
+        //db.set_sql_logging()
+        const table = await Table.create("TableWithDates");
+        await Field.create({
+            table,
+            name: "time",
+            type: "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);
+    });
+});
+describe("Tables with name clashes", () => {
+    it("should create tables", async () => {
+        //db.set_sql_logging()
+        const cars = await Table.create("TableClashCar");
+        const persons = await Table.create("TableClashPerson");
+        await Field.create({
+            table: persons,
+            name: "name",
+            type: "String",
+        });
+        await Field.create({
+            table: cars,
+            name: "name",
+            type: "String",
+        });
+        await Field.create({
+            table: cars,
+            name: "owner",
+            type: "Key to TableClashPerson",
+        });
+        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" });
+        const rows = await cars.getJoinedRows({
+            joinFields: {
+                owner_name: { ref: "owner", target: "name" },
+            },
+        });
+        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({
+            table_id: cars.id,
+            name: "patientlist",
+            viewtemplate: "List",
+            configuration: {
+                columns: [
+                    { type: "Field", field_name: "name" },
+                    { type: "JoinField", join_field: "owner.name" },
+                ],
+            },
+            min_role: 10,
+        });
+        const res = await v.run({}, mockReqRes);
+        expect(res).toContain("Mustang");
+        expect(res).toContain("Sally");
+    });
+    it("should show show view", async () => {
+        const cars = await Table.findOne({ name: "TableClashCar" });
+        const v = await View.create({
+            table_id: cars.id,
+            name: "patientlist",
+            viewtemplate: "Show",
+            configuration: {
+                columns: [
+                    { type: "Field", field_name: "name" },
+                    { type: "JoinField", join_field: "owner.name" },
+                ],
+                layout: {
+                    above: [
+                        { type: "field", fieldview: "show", field_name: "name" },
+                        { type: "join_field", join_field: "owner.name" },
+                    ],
+                },
+            },
+            min_role: 10,
+        });
+        const res = await v.run({ id: 1 }, mockReqRes);
+        expect(res).toContain("Mustang");
+        expect(res).toContain("Sally");
+    });
+});
+describe("Table joint unique constraint", () => {
+    it("should create table", async () => {
+        const table = await Table.findOne({ name: "books" });
+        const rows = await table.getRows();
+        const { id, ...row0 } = rows[0];
+        const tc = await TableConstraint.create({
+            table_id: table.id,
+            type: "Unique",
+            configuration: { fields: ["author", "pages"] },
+        });
+        const res = await table.tryInsertRow(row0);
+        expect(!!res.error).toBe(true);
+        await tc.delete();
+        const res1 = await table.tryInsertRow(row0);
+        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({
+            table: persons,
+            name: "name",
+            type: "String",
+        });
+        const age = await Field.create({
+            table: persons,
+            name: "age",
+            type: "String",
+        });
+        const owner = await Field.create({
+            table: persons,
+            name: "owner",
+            type: "Key to users",
+        });
+        await persons.update({ ownership_field_id: owner.id });
+        if (!db.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);
+            const owner_fnm = await persons.owner_fieldname();
+            expect(owner_fnm).toBe("owner");
+            const is_owner = await persons.is_owner({ id: 6 }, row);
+            expect(is_owner).toBe(false);
+            const row1 = await persons.getRow({ age: 13 });
+            const is_owner1 = await persons.is_owner({ id: 1 }, row1);
+            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({
+            table: persons,
+            name: "name",
+            type: "String",
+        });
+        const age = await Field.create({
+            table: persons,
+            name: "age",
+            type: "String",
+        });
+        const owner = await Field.create({
+            table: persons,
+            name: "owner",
+            type: "Key to users",
+        });
+        await persons.update({ ownership_formula: "user.id===owner" });
+        if (!db.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);
+            const is_owner = await persons.is_owner({ id: 6 }, row);
+            expect(is_owner).toBe(false);
+            const row1 = await persons.getRow({ age: 13 });
+            const is_owner1 = await persons.is_owner({ id: 1 }, row1);
+            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 () => {
+            getState().registerPlugin("mock_plugin", plugin_with_routes);
+            const table = await Table.create("TableUUID");
+            const [pk] = await table.getFields();
+            await pk.update({ type: "UUID" });
+            const name = await Field.create({
+                table: table,
+                name: "name",
+                type: "String",
+            });
+            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");
+            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");
+            const row = await table.getRow({ id: rows[0].id });
+            expect(row.name).toBe("Jim");
+        });
+        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);
+            const impres = await table.import_json_file(fnm);
+            expect(impres).toEqual({
+                success: "Imported 1 rows into table TableUUID",
+            });
+            const rows = await table.getRows();
+            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({
+                table: table,
+                name: "myname",
+                type: "String",
+            });
+            //db.set_sql_logging();
+            await Field.create({
+                table: table,
+                name: "follows",
+                type: "Key to TableUUID",
+            });
+            const refrows = await uuidtable1.getRows({});
+            await table.insertRow({ myname: "Fred", follows: refrows[0].id });
+            const rows = await table.getJoinedRows({
+                where: {},
+                joinFields: {
+                    leader: { ref: "follows", target: "name" },
+                },
+            });
+            //trying to debug intermittant CI failure
+            if (rows.length === 0) {
+                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");
+            await table.delete();
+            await uuidtable1.delete();
+        });
+        it("should create and delete table", async () => {
+            getState().registerPlugin("mock_plugin", plugin_with_routes);
+            const table = await Table.create("TableUUID1");
+            const [pk] = await table.getFields();
+            await pk.update({ type: "UUID" });
+            table.fields = null;
+            const [pk1] = await table.getFields();
+            await pk1.update({ type: "Integer" });
+            await table.delete();
+        });
+    }
+});
+describe("external tables", () => {
+    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");
+    });
+});
+describe("distance ordering", () => {
+    it("should create table", async () => {
+        const tc = await Table.create("geotable1");
+        await Field.create({
+            table: tc,
+            label: "Name",
+            type: "String",
+            required: true,
+        });
+        await Field.create({
+            table: tc,
+            label: "Lat",
+            type: "Float",
+            required: true,
+        });
+        await Field.create({
+            table: tc,
+            label: "Long",
+            type: "Float",
+            required: true,
+        });
+        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" });
+        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");
+        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");
+    });
+});
+//# sourceMappingURL=table.test.js.map