@saltcorn/data 0.9.4-beta.2 → 0.9.4-beta.20

package/dist/tests/table.test.js

@@ -248,6 +248,24 @@ jest.setTimeout(30000);
         (0, globals_1.expect)(michaels.length).toStrictEqual(2);
         (0, globals_1.expect)(Math.round(michaels[0].avg_temp)).toBe(38);
     });
+    (0, globals_1.it)("should get joined rows with filtered aggregations", async () => {
+        const patients = table_1.default.findOne({ name: "patients" });
+        (0, assertions_1.assertIsSet)(patients);
+        const michaels = await patients.getJoinedRows({
+            orderBy: "id",
+            aggregations: {
+                avg_temp: {
+                    table: "readings",
+                    ref: "patient_id",
+                    field: "temperature",
+                    aggregate: "avg",
+                    where: { normalised: true },
+                },
+            },
+        });
+        (0, globals_1.expect)(michaels.length).toStrictEqual(2);
+        (0, globals_1.expect)(Math.round(michaels[0].avg_temp)).toBe(37);
+    });
     (0, globals_1.it)("should get joined rows with unique count aggregations", async () => {
         const patients = table_1.default.findOne({ name: "patients" });
         (0, assertions_1.assertIsSet)(patients);
@@ -544,6 +562,139 @@ jest.setTimeout(30000);
         (0, globals_1.expect)(reads[0].pages).toBe(967);
     });
 });
+(0, globals_1.describe)("Table aggregationQuery", () => {
+    (0, globals_1.it)("should get avg aggregations", async () => {
+        const readings = table_1.default.findOne({ name: "readings" });
+        (0, assertions_1.assertIsSet)(readings);
+        const aggs = await readings.aggregationQuery({
+            avg_temp: {
+                field: "temperature",
+                aggregate: "avg",
+            },
+        });
+        (0, globals_1.expect)(Math.round(aggs.avg_temp)).toBe(38);
+    });
+    (0, globals_1.it)("should get filtered avg aggregations", async () => {
+        const readings = table_1.default.findOne({ name: "readings" });
+        (0, assertions_1.assertIsSet)(readings);
+        const aggs = await readings.aggregationQuery({
+            avg_temp: {
+                field: "temperature",
+                aggregate: "avg",
+            },
+        }, { where: { normalised: true } });
+        (0, globals_1.expect)(Math.round(aggs.avg_temp)).toBe(37);
+    });
+    (0, globals_1.it)("should get array aggregations", async () => {
+        const readings = table_1.default.findOne({ name: "readings" });
+        (0, assertions_1.assertIsSet)(readings);
+        if (!db_1.default.isSQLite) {
+            const aggs = await readings.aggregationQuery({
+                ids: {
+                    field: "id",
+                    aggregate: "array_agg",
+                },
+            });
+            (0, globals_1.expect)(aggs.ids).toStrictEqual([1, 2, 3]);
+        }
+    });
+    (0, globals_1.it)("should get filtered array aggregations", async () => {
+        const readings = table_1.default.findOne({ name: "readings" });
+        (0, assertions_1.assertIsSet)(readings);
+        if (!db_1.default.isSQLite) {
+            const aggs = await readings.aggregationQuery({
+                ids: {
+                    field: "id",
+                    aggregate: "array_agg",
+                },
+            }, { where: { normalised: true } });
+            (0, globals_1.expect)(aggs.ids).toStrictEqual([1]);
+        }
+    });
+    (0, globals_1.it)("should get grouped aggregations", async () => {
+        const readings = table_1.default.findOne({ name: "readings" });
+        (0, assertions_1.assertIsSet)(readings);
+        if (!db_1.default.isSQLite) {
+            const aggs = await readings.aggregationQuery({
+                temps: {
+                    field: "id",
+                    aggregate: "count",
+                },
+            }, { groupBy: ["patient_id"] });
+            (0, globals_1.expect)(aggs).toStrictEqual([
+                { patient_id: 2, temps: "1" },
+                { patient_id: 1, temps: "2" },
+            ]);
+        }
+    });
+    (0, globals_1.it)("sets up new fields", async () => {
+        const table = table_1.default.findOne({ name: "books" });
+        (0, assertions_1.assertIsSet)(table);
+        await field_1.default.create({
+            table,
+            name: "published",
+            label: "Published",
+            type: "Date",
+        });
+        await table.updateRow({ published: new Date("1971-05.04") }, 1);
+        await table.updateRow({ published: new Date("1972-05.04") }, 2);
+    });
+    (0, globals_1.it)("should get latest by field", async () => {
+        const books = table_1.default.findOne({ name: "books" });
+        (0, assertions_1.assertIsSet)(books);
+        if (!db_1.default.isSQLite) {
+            const aggs = await books.aggregationQuery({
+                pages: {
+                    field: "pages",
+                    aggregate: "Latest published",
+                },
+            });
+            (0, globals_1.expect)(aggs).toStrictEqual({ pages: 728 });
+        }
+    });
+    (0, globals_1.it)("should get latest by field, qualified", async () => {
+        const books = table_1.default.findOne({ name: "books" });
+        (0, assertions_1.assertIsSet)(books);
+        if (!db_1.default.isSQLite) {
+            const aggs = await books.aggregationQuery({
+                pages: {
+                    field: "pages",
+                    aggregate: "Latest published",
+                },
+            }, { where: { author: "Herman Melville" } });
+            (0, globals_1.expect)(aggs).toStrictEqual({ pages: 967 });
+        }
+    });
+    (0, globals_1.it)("should get latest by field, grouped", async () => {
+        const books = table_1.default.findOne({ name: "books" });
+        (0, assertions_1.assertIsSet)(books);
+        if (!db_1.default.isSQLite) {
+            const aggs = await books.aggregationQuery({
+                pages: {
+                    field: "pages",
+                    aggregate: "Latest published",
+                },
+            }, { groupBy: "author" });
+            (0, globals_1.expect)(aggs).toStrictEqual([
+                { author: "Leo Tolstoy", pages: 728 },
+                { author: "Herman Melville", pages: 967 },
+            ]);
+        }
+    });
+    (0, globals_1.it)("should get latest by field, grouped and qualified", async () => {
+        const books = table_1.default.findOne({ name: "books" });
+        (0, assertions_1.assertIsSet)(books);
+        if (!db_1.default.isSQLite) {
+            const aggs = await books.aggregationQuery({
+                pages: {
+                    field: "pages",
+                    aggregate: "Latest published",
+                },
+            }, { groupBy: "author", where: { author: "Herman Melville" } });
+            (0, globals_1.expect)(aggs).toStrictEqual([{ author: "Herman Melville", pages: 967 }]);
+        }
+    });
+});
 (0, globals_1.describe)("relations", () => {
     (0, globals_1.it)("get parent relations", async () => {
         const table = table_1.default.findOne({ name: "patients" });
@@ -597,54 +748,20 @@ jest.setTimeout(30000);
         const table = table_1.default.findOne({ name: "readings" });
         (0, assertions_1.assertIsSet)(table);
         const rels = await table.get_parent_relations(true);
-        const expected = [
-            "patient_id.favbook",
-            "patient_id.favbook.author",
-            "patient_id.favbook.id",
-            "patient_id.favbook.pages",
-            "patient_id.favbook.publisher",
-            "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",
-        ];
-        (0, globals_1.expect)(rels.parent_field_list).toHaveLength(expected.length);
-        (0, globals_1.expect)(rels.parent_field_list).toEqual(globals_1.expect.arrayContaining(expected));
+        (0, globals_1.expect)(rels.parent_field_list.length).toBeGreaterThan(10);
+        (0, globals_1.expect)(rels.parent_field_list).toContain("patient_id.favbook.publisher");
+        (0, globals_1.expect)(rels.parent_field_list).toContain("patient_id.name");
         (0, globals_1.expect)(rels.parent_relations.length).toBe(3);
     });
     (0, globals_1.it)("get triple relations", async () => {
         const table = table_1.default.findOne({ name: "readings" });
         (0, assertions_1.assertIsSet)(table);
         const rels = await table.get_parent_relations(true, true);
-        const expected = [
-            "patient_id.favbook",
-            "patient_id.favbook.author",
-            "patient_id.favbook.id",
-            "patient_id.favbook.pages",
-            "patient_id.favbook.publisher",
-            "patient_id.favbook.publisher.id",
-            "patient_id.favbook.publisher.name",
-            "patient_id.id",
-            "patient_id.name",
-            "patient_id.parent",
-            "patient_id.parent.favbook",
-            "patient_id.parent.favbook.author",
-            "patient_id.parent.favbook.id",
-            "patient_id.parent.favbook.pages",
-            "patient_id.parent.favbook.publisher",
-            "patient_id.parent.id",
-            "patient_id.parent.name",
-            "patient_id.parent.parent",
-            "patient_id.parent.parent.favbook",
-            "patient_id.parent.parent.id",
-            "patient_id.parent.parent.name",
-            "patient_id.parent.parent.parent",
-        ];
-        (0, globals_1.expect)(rels.parent_field_list).toHaveLength(expected.length);
-        (0, globals_1.expect)(rels.parent_field_list).toEqual(globals_1.expect.arrayContaining(expected));
+        (0, globals_1.expect)(rels.parent_field_list.length).toBeGreaterThan(10);
+        (0, globals_1.expect)(rels.parent_field_list).toContain("patient_id.parent.favbook.author");
+        (0, globals_1.expect)(rels.parent_field_list).toContain("patient_id.favbook.publisher.name");
+        (0, globals_1.expect)(rels.parent_field_list).toContain("patient_id.favbook.author");
+        (0, globals_1.expect)(rels.parent_field_list).toContain("patient_id.name");
         (0, globals_1.expect)(rels.parent_relations.length).toBe(3);
     });
 });
@@ -706,6 +823,29 @@ Peter Rossi, 212,9,200`;
         (0, globals_1.expect)(row?.pages).toBe(540);
         await table.updateRow({ author: "Herman Melville" }, 1);
     });
+    (0, globals_1.it)("should replace when id given in preview", async () => {
+        const csv = `id,author,Pages
+1, Noam Chomsky, 540
+18, Cornel West, 678`;
+        const fnm = "/tmp/testreplaceid.csv";
+        await (0, promises_1.writeFile)(fnm, csv);
+        const table = 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, { no_table_write: true });
+        (0, assertions_1.assertsIsSuccessMessage)(impres);
+        const rows = impres.rows;
+        (0, assertions_1.assertIsSet)(rows);
+        (0, globals_1.expect)(rows.length).toBe(2);
+        const row = rows.find((r) => r.id == 1);
+        (0, globals_1.expect)(row?.pages).toBe(540);
+        (0, globals_1.expect)(row.author).toBe("Noam Chomsky");
+        const row1 = rows.find((r) => r.id == 18);
+        (0, globals_1.expect)(row1?.pages).toBe(678);
+        const rowDB = await table.getRow({ id: 1 });
+        (0, assertions_1.assertIsSet)(rowDB);
+        (0, globals_1.expect)(rowDB.author).toBe("Herman Melville");
+    });
     (0, globals_1.it)("fail on required field", async () => {
         const csv = `author,Pagez
 Joe Celko, 856
@@ -1648,20 +1788,8 @@ Pencil, 0.5,2, t`;
     (0, globals_1.it)("should find one-level join fields", async () => {
         const table = table_1.default.findOne({ name: "patients" });
         const opts = await table?.field_options(1);
-        (0, globals_1.expect)(opts).toStrictEqual([
-            "favbook",
-            "id",
-            "name",
-            "parent",
-            "favbook.author",
-            "favbook.id",
-            "favbook.pages",
-            "favbook.publisher",
-            "parent.favbook",
-            "parent.id",
-            "parent.name",
-            "parent.parent",
-        ]);
+        (0, globals_1.expect)(opts).toContain("parent.name");
+        (0, globals_1.expect)(opts).toContain("favbook.pages");
     });
     (0, globals_1.it)("should find string fields", async () => {
         const table = table_1.default.findOne({ name: "patients" });