@galadrim/galadmin 0.1.236 → 0.2.7

package/tests/integration/routes.integration.test.ts

@@ -0,0 +1,366 @@
+import * as request from "supertest";
+import { buildAppForManager } from "../helpers/app";
+import { baseConfig, fruitView } from "../helpers/fixtures";
+import {
+  DbHarness,
+  describeIntegration,
+  getMysql2Harness,
+  getMysqlHarness,
+  getPgHarness,
+  resetTables,
+} from "./dbHarness";
+
+jest.mock("axios");
+
+const CONTAINER_TIMEOUT = 300000;
+
+// The primaryId is declared explicitly in every view config below because
+// config enrichment silently no-ops on PostgreSQL (see the enrichment
+// characterization test at the bottom — GAP 10).
+
+describeIntegration("routes against real databases", () => {
+  let mysqlHarness: DbHarness;
+  let mysql2Harness: DbHarness;
+  let pgHarness: DbHarness;
+  const harnesses: Record<string, DbHarness> = {};
+
+  beforeAll(async () => {
+    mysqlHarness = await getMysqlHarness();
+    harnesses.mysql = mysqlHarness;
+    mysql2Harness = await getMysql2Harness();
+    harnesses.mysql2 = mysql2Harness;
+    pgHarness = await getPgHarness();
+    harnesses.postgresql = pgHarness;
+  }, CONTAINER_TIMEOUT);
+
+  afterAll(async () => {
+    // Close the pools; the containers themselves live until globalTeardown.
+    await mysqlHarness?.stop();
+    await mysql2Harness?.stop();
+    await pgHarness?.stop();
+  });
+
+  describe.each([
+    ["mysql", () => harnesses.mysql],
+    ["mysql2", () => harnesses.mysql2],
+    ["postgresql", () => harnesses.postgresql],
+  ])("backend: %s", (_backend, getHarness) => {
+    let harness: DbHarness;
+
+    beforeEach(async () => {
+      harness = getHarness();
+      await resetTables(harness);
+    });
+
+    const app = () =>
+      buildAppForManager(
+        harness.manager,
+        baseConfig({ views: [fruitView({ primaryId: "id" })] }),
+      );
+
+    it("POST /createRecord persists the row", async () => {
+      const res = await request(app())
+        .post("/api/createRecord")
+        .send({ viewIndex: 0, data: { fruitName: "pomme", acidity: 3 } })
+        .expect(200);
+      if (harness.dbType === "MYSQL") {
+        expect(res.body.id).toBe(1);
+      } else {
+        // CHARACTERIZATION (GAP 11): pg results carry no insertId, so the
+        // created id is undefined in the response on PostgreSQL.
+        expect(res.body.id).toBeUndefined();
+      }
+      const { err, rows } = await harness.query("SELECT * FROM fruits");
+      expect(err ?? null).toBeNull();
+      expect(rows).toHaveLength(1);
+      expect(rows[0].fruitName ?? rows[0].fruitname).toBe("pomme");
+      expect(Number(rows[0].acidity)).toBe(3);
+    });
+
+    it("POST /updateRecord updates the persisted row", async () => {
+      await request(app())
+        .post("/api/createRecord")
+        .send({ viewIndex: 0, data: { fruitName: "pomme", acidity: 3 } })
+        .expect(200);
+      await request(app())
+        .post("/api/updateRecord")
+        .send({ viewIndex: 0, primaryValue: 1, data: { fruitName: "poire" } })
+        .expect(200);
+      const { rows } = await harness.query("SELECT * FROM fruits");
+      expect(rows).toHaveLength(1);
+      expect(rows[0].fruitName ?? rows[0].fruitname).toBe("poire");
+    });
+
+    it("POST /deleteRecord removes the row, then answers 404 once gone", async () => {
+      await request(app())
+        .post("/api/createRecord")
+        .send({ viewIndex: 0, data: { fruitName: "pomme" } })
+        .expect(200);
+      await request(app())
+        .post("/api/deleteRecord")
+        .send({ viewIndex: 0, primaryValue: 1 })
+        .expect(200);
+      const { rows } = await harness.query("SELECT * FROM fruits");
+      expect(rows).toHaveLength(0);
+      await request(app())
+        .post("/api/deleteRecord")
+        .send({ viewIndex: 0, primaryValue: 1 })
+        .expect(404);
+    });
+
+    it("POST /deleteRecords removes several rows by primary value", async () => {
+      const appInstance = app();
+      await request(appInstance)
+        .post("/api/createRecord")
+        .send({ viewIndex: 0, data: { fruitName: "pomme" } })
+        .expect(200);
+      await request(appInstance)
+        .post("/api/createRecord")
+        .send({ viewIndex: 0, data: { fruitName: "poire" } })
+        .expect(200);
+      await request(appInstance)
+        .post("/api/deleteRecords")
+        .send({ viewIndex: 0, primaryValues: ["1", "2"] })
+        .expect(200);
+      const { rows } = await harness.query("SELECT * FROM fruits");
+      expect(rows).toHaveLength(0);
+    });
+
+    it("POST /records lists rows with pagination, search and count", async () => {
+      const appInstance = app();
+      for (const name of ["pomme", "poire", "banane"]) {
+        await request(appInstance)
+          .post("/api/createRecord")
+          .send({ viewIndex: 0, data: { fruitName: name } })
+          .expect(200);
+      }
+      const res = await request(appInstance)
+        .post("/api/records")
+        .send({ viewIndex: 0, page: 1, filters: [] })
+        .expect(200);
+      expect(res.body.records).toHaveLength(3);
+      // PG returns COUNT(*) as a bigint, which node-pg surfaces as a string.
+      expect(String(res.body.count)).toBe("3");
+
+      // The LIKE -> ::text ILIKE rewrite must actually run on the engine.
+      const search = await request(appInstance)
+        .post("/api/records")
+        .send({ viewIndex: 0, page: 1, filters: [], query: "pomme" })
+        .expect(200);
+      expect(search.body.records).toHaveLength(1);
+      expect(search.body.records[0].fruitName).toBe("pomme");
+
+      const noMatch = await request(appInstance)
+        .post("/api/records")
+        .send({ viewIndex: 0, page: 1, filters: [], query: "cerise" })
+        .expect(200);
+      expect(noMatch.body.records).toHaveLength(0);
+    });
+
+    it("GET /record returns the persisted record", async () => {
+      const appInstance = app();
+      await request(appInstance)
+        .post("/api/createRecord")
+        .send({ viewIndex: 0, data: { fruitName: "pomme", acidity: 3 } })
+        .expect(200);
+      const res = await request(appInstance)
+        .get("/api/record")
+        .query({ viewIndex: 0, recordId: 1 })
+        .expect(200);
+      expect(res.body.fruitName).toBe("pomme");
+    });
+
+    it("a read-only role cannot write, and the row stays untouched", async () => {
+      const viewerApp = buildAppForManager(
+        harness.manager,
+        baseConfig({
+          views: [
+            fruitView({
+              primaryId: "id",
+              roles: ["editor"],
+              readRoles: ["viewer"],
+            }),
+          ],
+        }),
+        { role: "viewer", userId: 3 },
+      );
+      await request(app())
+        .post("/api/createRecord")
+        .send({ viewIndex: 0, data: { fruitName: "pomme" } })
+        .expect(200);
+      await request(viewerApp)
+        .post("/api/updateRecord")
+        .send({ viewIndex: 0, primaryValue: 1, data: { fruitName: "hack" } })
+        .expect(403);
+      const { rows } = await harness.query("SELECT * FROM fruits");
+      expect(rows[0].fruitName ?? rows[0].fruitname).toBe("pomme");
+    });
+
+    it("POST /recordsImport upserts rows (idempotent re-import)", async () => {
+      const parseImportFile = jest
+        .fn()
+        .mockResolvedValueOnce([
+          { id: 1, fruitName: "pomme" },
+          { id: 2, fruitName: "poire" },
+        ])
+        .mockResolvedValueOnce([{ id: 1, fruitName: "POMME-IMPORTED" }]);
+      const appInstance = buildAppForManager(
+        harness.manager,
+        baseConfig({
+          views: [
+            fruitView({
+              primaryId: "id",
+              importFileUniqueField: "id",
+              parseImportFile,
+            }),
+          ],
+        }),
+      );
+
+      if (harness.dbType === "POSTGRESQL") {
+        // quotePostgresQuery now knows the ON CONFLICT / EXCLUDED keywords,
+        // so the upsert runs on a real engine too (GAP 12 fixed): same
+        // assertions as the MySQL branch.
+        await request(appInstance)
+          .post("/api/recordsImport")
+          .field("viewIndex", "0")
+          .attach("data", Buffer.from("csv"), "import.csv")
+          .expect(200);
+        let { rows } = await harness.query(
+          "SELECT * FROM fruits ORDER BY id",
+        );
+        expect(rows).toHaveLength(2);
+
+        // Re-import the same id: upsert, not duplicate.
+        await request(appInstance)
+          .post("/api/recordsImport")
+          .field("viewIndex", "0")
+          .attach("data", Buffer.from("csv"), "import.csv")
+          .expect(200);
+        ({ rows } = await harness.query("SELECT * FROM fruits ORDER BY id"));
+        expect(rows).toHaveLength(2);
+        expect(rows[0].fruitName ?? rows[0].fruitname).toBe("POMME-IMPORTED");
+      } else {
+        await request(appInstance)
+          .post("/api/recordsImport")
+          .field("viewIndex", "0")
+          .attach("data", Buffer.from("csv"), "import.csv")
+          .expect(200);
+        let { rows } = await harness.query(
+          "SELECT * FROM fruits ORDER BY id",
+        );
+        expect(rows).toHaveLength(2);
+
+        // Re-import the same id: upsert, not duplicate.
+        await request(appInstance)
+          .post("/api/recordsImport")
+          .field("viewIndex", "0")
+          .attach("data", Buffer.from("csv"), "import.csv")
+          .expect(200);
+        ({ rows } = await harness.query("SELECT * FROM fruits ORDER BY id"));
+        expect(rows).toHaveLength(2);
+        expect(rows[0].fruitName ?? rows[0].fruitname).toBe("POMME-IMPORTED");
+      }
+    });
+
+    it("POST /foreignSelectRecords searches with a quoted term", async () => {
+      const searchColumn = {
+        label: "Nom",
+        name: "fruitName",
+        table: "fruits",
+        searchableName: "fruitName",
+        __id__: "foreign-col",
+      };
+      const appInstance = buildAppForManager(
+        harness.manager,
+        baseConfig({
+          views: [
+            fruitView({
+              primaryId: "id",
+              columns: [
+                searchColumn,
+                { label: "Acidité", name: "acidity" },
+              ],
+            }),
+          ],
+        }),
+      );
+      await request(appInstance)
+        .post("/api/createRecord")
+        .send({ viewIndex: 0, data: { fruitName: "l'orange" } })
+        .expect(200);
+      if (harness.dbType === "POSTGRESQL") {
+        // The PG branch of the route escapes quotes with doubling (''),
+        // which is valid under standard_conforming_strings — the search
+        // works on a real engine (unlike the /records search, GAP 7).
+        const res = await request(appInstance)
+          .post("/api/foreignSelectRecords")
+          .send({ viewIndex: 0, columnId: "foreign-col", query: "l'orange" })
+          .expect(200);
+        expect(res.body).toHaveLength(1);
+        expect(res.body[0].value).toBe("l'orange");
+      } else {
+        const res = await request(appInstance)
+          .post("/api/foreignSelectRecords")
+          .send({ viewIndex: 0, columnId: "foreign-col", query: "l'orange" })
+          .expect(200);
+        expect(res.body).toHaveLength(1);
+        // The label/value default to the column's own value.
+        expect(res.body[0].value).toBe("l'orange");
+        expect(res.body[0].label).toBe("l'orange");
+      }
+    });
+  });
+});
+
+describeIntegration("config enrichment against real information_schema", () => {
+  let mysqlHarness: DbHarness;
+  let pgHarness: DbHarness;
+
+  beforeAll(async () => {
+    mysqlHarness = await getMysqlHarness();
+    pgHarness = await getPgHarness();
+  }, CONTAINER_TIMEOUT);
+
+  afterAll(async () => {
+    await mysqlHarness?.stop();
+    await pgHarness?.stop();
+  });
+
+  it("resolves the primary key on MySQL without a declared primaryId", async () => {
+    const { rows } = await mysqlHarness.query(
+      "SELECT * FROM information_schema.columns WHERE table_schema = ?",
+      ["galadmin_test"],
+    );
+    const pri = rows.find(
+      (r: any) => r.TABLE_NAME === "fruits" && r.COLUMN_KEY === "PRI",
+    );
+    expect(pri.COLUMN_NAME).toBe("id");
+  });
+
+  it("CHARACTERIZATION (GAP 10): pg information_schema returns lowercase keys, so enrichment no-ops", async () => {
+    // 1) The probe enrichConfig actually runs filters by DATABASE name —
+    //    correct on MySQL, but on PostgreSQL table_schema is the SCHEMA
+    //    ("public"), so the probe matches nothing at all.
+    const { rows: probeRows } = await pgHarness.query(
+      "SELECT * FROM information_schema.columns WHERE table_schema = ?",
+      ["galadmin_test"],
+    );
+    expect(probeRows).toHaveLength(0);
+
+    // 2) Even probing the right schema, the keys are lowercase and there is
+    //    no COLUMN_KEY — enrichConfig only looks for TABLE_NAME/COLUMN_KEY/
+    //    COLUMN_NAME/COLUMN_TYPE, so primaryId detection, `required` flags
+    //    and enum->select mapping silently never fire on PostgreSQL.
+    const { err, rows } = await pgHarness.query(
+      "SELECT * FROM information_schema.columns WHERE table_schema = ?",
+      ["public"],
+    );
+    if (err) throw err;
+    expect(rows.length).toBeGreaterThan(0);
+    const first = rows[0];
+    expect(first.TABLE_NAME).toBeUndefined();
+    expect(first.table_name).toBeDefined();
+    expect(first.column_key).toBeUndefined();
+  });
+});

package/tests/integration/routes.postgresql.integration.test.ts

@@ -0,0 +1,88 @@
+import * as request from "supertest";
+import { buildAppForManager } from "../helpers/app";
+import { baseConfig, fruitView, EDITOR } from "../helpers/fixtures";
+import {
+  BackendName,
+  DbHarness,
+  describeIntegration,
+  getMysql2Harness,
+  getMysqlHarness,
+  getPgHarness,
+  resetTables,
+} from "./dbHarness";
+
+jest.mock("axios");
+
+/**
+ * The MySQL -> PostgreSQL conversion pipeline (convertQuery ->
+ * quotePostgresQuery) checked against the real engines. Its other behaviors —
+ * identifier quoting, $N placeholders, NULL normalization, doubled-quote
+ * escaping, ILIKE rewriting, the count subquery — are pinned behaviorally by
+ * the crud/records/authorization suites running on the PostgreSQL backend.
+ * This suite keeps only what nothing else exercises.
+ */
+describeIntegration("SQL conversion pipeline against real databases", () => {
+  const harnesses: Record<BackendName, DbHarness> = {} as any;
+
+  beforeAll(async () => {
+    harnesses.mysql = await getMysqlHarness();
+    harnesses.mysql2 = await getMysql2Harness();
+    harnesses.postgresql = await getPgHarness();
+  });
+
+  afterAll(async () => {
+    await harnesses.mysql?.stop();
+    await harnesses.mysql2?.stop();
+    await harnesses.postgresql?.stop();
+  });
+
+  describe.each([
+    ["mysql", () => harnesses.mysql],
+    ["mysql2", () => harnesses.mysql2],
+    ["postgresql", () => harnesses.postgresql],
+  ])("backend: %s", (_backend, getHarness) => {
+    let harness: DbHarness;
+
+    beforeEach(async () => {
+      harness = getHarness();
+      await resetTables(harness);
+    });
+
+    const app = () =>
+      buildAppForManager(
+        harness.manager,
+        baseConfig({ views: [fruitView({ primaryId: "id" })] }),
+        EDITOR,
+      );
+
+    const postRecords = (instance: any, body: any) =>
+      request(instance).post("/api/records").send({
+        viewIndex: 0,
+        page: 1,
+        filters: [],
+        ...body,
+      });
+
+    const idsOf = (records: any[]) => records.map((r: any) => Number(r.id));
+
+    it("keeps a literal '?' in the search out of the placeholder conversion", async () => {
+      // The search term is interpolated as a string literal BEFORE the
+      // MySQL -> PostgreSQL conversion runs; a '?' inside it must survive as
+      // text instead of becoming a $N placeholder that consumes a parameter
+      // slot and shifts every real parameter (PG would fail the statement).
+      const instance = app();
+      await request(instance)
+        .post("/api/createRecord")
+        .send({ viewIndex: 0, data: { fruitName: "what? pomme" } })
+        .expect(200);
+      await request(instance)
+        .post("/api/createRecord")
+        .send({ viewIndex: 0, data: { fruitName: "pomme" } })
+        .expect(200);
+      const res = await postRecords(instance, { query: "what?" }).expect(200);
+      expect(idsOf(res.body.records)).toEqual([1]);
+      // The count subquery wraps the same literal-bearing query.
+      expect(String(res.body.count)).toBe("1");
+    });
+  });
+});