@galadrim/galadmin 0.2.12 → 0.3.0-alpha.2.1

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

@@ -1,4 +1,7 @@
 import * as request from "supertest";
+import { fork } from "child_process";
+import * as path from "path";
+import type { FormDataFile } from "../../src/types/config";
 import { buildAppForManager } from "../helpers/app";
 import { baseConfig, fruitView, EDITOR, VIEWER } from "../helpers/fixtures";
 import {
@@ -149,7 +152,7 @@ describeIntegration("import/export routes against real databases", () => {
         expect(dataLines(res.body.content)[0]).toMatch(/^keep;/);
       });
 
-      it("scopes the export to the caller's rows via filtersFromUser", async () => {
+      it("FILTER USER POLICY: scopes the export to the caller's rows via filtersFromUser", async () => {
         // The export must be scoped exactly like the list view, otherwise a
         // user could download rows their filtersFromUser clause hides.
         await seedFruits([
@@ -157,7 +160,8 @@ describeIntegration("import/export routes against real databases", () => {
           { fruitName: "theirs", ownerId: 1 },
         ]);
         const config = exportConfig({
-          filtersFromUser: (userId: number) => `ownerId = ${userId}`,
+          filtersFromUser: (user: { role: string; userId?: string | number }) =>
+                user.role === "root" ? "" : typeof user.userId === "number" ? `ownerId = ${user.userId}` : "1 = 0",
         });
         const res = await postExport(
           buildAppForManager(harness.manager, config, {
@@ -272,10 +276,165 @@ describeIntegration("import/export routes against real databases", () => {
         expect(rows).toHaveLength(0);
       });
 
-      // NOTE: a throwing parseImportFile is awaited OUTSIDE the try/catch of
-      // the multiparty callback -> unhandled rejection, the 500 is never sent
-      // and the process can crash. Listed in README under "Known robustness
-      // limitations".
+      it("preserves custom rows, inherited columns, field identities and getter timing", async () => {
+        const events: string[] = [];
+        const note = {
+          toJSON() {
+            expect(this).toBe(note);
+            events.push("serialize note");
+            return { ripe: true };
+          },
+        };
+        class Fruit {
+          id = 1;
+          acidity = 0;
+          note = note;
+          age = false;
+        }
+        const first = new Fruit();
+        Object.defineProperty(Fruit.prototype, "slug", {
+          enumerable: true,
+          get() {
+            expect(this).toBe(first);
+            events.push("read inherited slug");
+            return "inherited";
+          },
+        });
+        Object.defineProperty(first, "fruitName", {
+          enumerable: true,
+          get() {
+            expect(this).toBe(first);
+            events.push("read fruit name");
+            return "pomme d'hiver";
+          },
+        });
+        const records = [first, { id: 2, fruitName: "poire", acidity: 4 }];
+        let iterations = 0;
+        Object.defineProperty(records, Symbol.iterator, {
+          value: function () {
+            expect(this).toBe(records);
+            iterations++;
+            return Array.prototype.values.call(this);
+          },
+        });
+        let parserCalls = 0;
+        const parseImportFile = async function (file: FormDataFile) {
+          parserCalls++;
+          expect(arguments).toHaveLength(1);
+          expect(file.originalFilename).toBe("import.csv");
+          expect(this.parseImportFile).toBe(parseImportFile);
+          expect(this.tableName).toBe("fruits");
+          expect(events).toEqual([]);
+          return records;
+        };
+        await postImport(buildAppForManager(harness.manager, importConfig({ parseImportFile }))).expect(200);
+        expect(parserCalls).toBe(1);
+        expect(iterations).toBe(2);
+        expect(records[0]).toBe(first);
+        expect(first.note).toBe(note);
+        expect(events).toEqual(["serialize note", "read fruit name", "read inherited slug"]);
+        const { rows } = await harness.query("SELECT id, fruitName, acidity, note, age, slug FROM fruits ORDER BY id");
+        expect(rows).toEqual([
+          { id: 1, fruitName: "pomme d'hiver", acidity: 0, note: '{"ripe":true}', age: null, slug: "inherited" },
+          { id: 2, fruitName: "poire", acidity: 4, note: null, age: null, slug: null },
+        ]);
+      });
+
+      it("rejects hidden inherited columns before reading their getters", async () => {
+        let getterCalls = 0;
+        const record = Object.create({
+          get note() {
+            getterCalls++;
+            throw new Error("hidden field was read");
+          },
+        });
+        record.id = 1;
+        const config = importConfig({
+          columns: [{ label: "Secret", name: "note", roles: ["editor"] }],
+          parseImportFile: async () => [record],
+        });
+        await postImport(buildAppForManager(harness.manager, config)).expect(403);
+        expect(getterCalls).toBe(0);
+        expect((await harness.query("SELECT * FROM fruits")).rows).toHaveLength(0);
+      });
+
+      it("keeps Date field identity and the existing unquoted ISO insertion error", async () => {
+        const date = new Date("2026-10-06T12:00:00.000Z");
+        let calls = 0;
+        date.toISOString = function () {
+          expect(this).toBe(date);
+          calls++;
+          return Date.prototype.toISOString.call(this);
+        };
+        const config = importConfig({ parseImportFile: async () => [{ id: 1, note: date }] });
+        const res = await postImport(buildAppForManager(harness.manager, config)).expect(500);
+        expect(res.body.message).toBe("Une erreur est survenue.");
+        expect(calls).toBe(1);
+        expect((await harness.query("SELECT * FROM fruits")).rows).toHaveLength(0);
+      });
+
+      const isolatedParser = (parserCase: string): Promise<unknown> => new Promise((resolve, reject) => {
+        const child = fork(path.join(__dirname, "importParserChild.cjs"), [], {
+          env: { ...process.env, IMPORT_BACKEND: _backend, IMPORT_CASE: parserCase },
+          stdio: ["ignore", "ignore", "pipe", "ipc"],
+        });
+        let result: unknown;
+        let errors = "";
+        child.stderr?.on("data", (chunk) => { errors += chunk.toString(); });
+        child.on("message", (message) => { result = message; });
+        child.on("error", reject);
+        child.on("exit", (code) => code === 0 ? resolve(result) : reject(new Error(errors || `Child exited ${code}`)));
+      });
+
+      it.each([ ["throw", "parser sync failure"], ["reject", "parser async failure"] ])(
+        "preserves an unhandled parser %s outside the insertion catch", async (parserCase, message) => {
+          expect(await isolatedParser(parserCase)).toEqual({ kind: "unhandled", message });
+          expect((await harness.query("SELECT * FROM fruits")).rows).toHaveLength(0);
+        },
+      );
+
+      // Approved remediation: these assertions fail on the original route.
+      it.each(["null", "undefined"])("SANITIZATION: rejects top-level %s before insertion", async (parserCase) => {
+        expect(await isolatedParser(parserCase)).toEqual({ kind: "response", status: 400, body: {} });
+        expect((await harness.query("SELECT * FROM fruits")).rows).toHaveLength(0);
+      });
+
+      it("SANITIZATION: validates all row shapes before reading any field", async () => {
+        let reads = 0;
+        const first = {
+          id: 1,
+          get fruitName() {
+            reads++;
+            return "must not insert";
+          },
+        };
+        const config = importConfig({ parseImportFile: async () => [first, null] });
+        const res = await postImport(buildAppForManager(harness.manager, config));
+        const { rows } = await harness.query("SELECT * FROM fruits");
+        expect({ status: res.status, reads, rows }).toEqual({ status: 400, reads: 0, rows: [] });
+      });
+
+      it.each([
+        ["object with empty length", () => ({ length: 0 })],
+        ["string result", () => "ab"],
+        ["number result", () => 17],
+        ["boolean result", () => true],
+        ["function result", () => function () {}],
+        ["string row", () => [{ id: 1, fruitName: "must not insert" }, "ab"]],
+        ["number row", () => [{ id: 1, fruitName: "must not insert" }, 17]],
+        ["boolean row", () => [{ id: 1, fruitName: "must not insert" }, true]],
+        ["null row", () => [{ id: 1, fruitName: "must not insert" }, null]],
+        ["undefined row", () => [{ id: 1, fruitName: "must not insert" }, undefined]],
+        ["array row", () => [{ id: 1, fruitName: "must not insert" }, []]],
+        ["function row", () => [{ id: 1, fruitName: "must not insert" }, function () {}]],
+        ["sparse hole", () => { const rows = [{ id: 1, fruitName: "must not insert" }]; rows.length = 2; return rows; }],
+      ])("SANITIZATION: rejects %s without partial insertion", async (_label, result) => {
+        const config = importConfig({ parseImportFile: async () => result() });
+        const res = await postImport(buildAppForManager(harness.manager, config));
+        // Inspect the real table before asserting the new HTTP policy.
+        const { rows } = await harness.query("SELECT * FROM fruits");
+        expect({ status: res.status, rows }).toEqual({ status: 400, rows: [] });
+      });
 
       it("returns 500 with a message when the insert fails", async () => {
         const config = importConfig({
@@ -318,6 +477,149 @@ describeIntegration("import/export routes against real databases", () => {
           .field("recordId", "7")
           .attach("data", Buffer.from("fake,csv"), "notes.csv");
 
+      it.each([
+        { label: "absent roles", roles: undefined, user: EDITOR, status: 200 },
+        { label: "empty roles", roles: [], user: EDITOR, status: 403 },
+        { label: "allowed role", roles: ["editor"], user: EDITOR, status: 200 },
+        { label: "denied role", roles: ["editor"], user: VIEWER, status: 403 },
+        { label: "root with empty roles", roles: [], user: { role: "root" }, status: 200 },
+        { label: "root with restricted roles", roles: ["editor"], user: { role: "root" }, status: 200 },
+      ])("preserves panel authorization for $label before parsing", async ({ roles, user, status }) => {
+        let calls = 0;
+        const config = panelConfig({ roles, parseImportFile: async () => { calls++; return []; } });
+        const response = await postSubImport(buildAppForManager(harness.manager, config, user)).expect(status);
+        expect(calls).toBe(status === 200 ? 1 : 0);
+        if (status === 200) expect(response.body).toEqual({ affectedRows: 0 });
+        expect((await harness.query("SELECT * FROM fruit_notes")).rows).toEqual([]);
+      });
+
+      it("checks view authorization before panel configuration or parsing", async () => {
+        let calls = 0;
+        const config = panelConfig({ roles: ["viewer"], createConfig: undefined,
+          parseImportFile: async () => { calls++; return []; } });
+        config.views[0].roles = ["editor"];
+        config.views[0].readRoles = ["viewer"];
+        await postSubImport(buildAppForManager(harness.manager, config, VIEWER)).expect(403);
+        expect(calls).toBe(0);
+        expect((await harness.query("SELECT * FROM fruit_notes")).rows).toEqual([]);
+      });
+
+      it("preserves inherited fields, getters, identities, mixed values and parser receiver/parent arguments", async () => {
+        const events: string[] = [];
+        const note = { toJSON() { expect(this).toBe(note); events.push("serialize"); return { ripe: true }; } };
+        class Fruit { id = 1; acidity = 0; age = false; note = note; }
+        const first = new Fruit();
+        Object.defineProperty(Fruit.prototype, "slug", { enumerable: true, get() {
+          expect(this).toBe(first); events.push("inherited"); return "inherited";
+        } });
+        Object.defineProperty(first, "fruitName", { enumerable: true, get() {
+          expect(this).toBe(first); events.push("name"); return "pomme d'hiver";
+        } });
+        const records = [first, { id: 2, fruitName: "poire", acidity: 4 }];
+        let iterations = 0;
+        Object.defineProperty(records, Symbol.iterator, { value: function () {
+          expect(this).toBe(records); iterations++; return Array.prototype.values.call(this);
+        } });
+        let calls = 0;
+        const parseImportFile = async function (file: FormDataFile, id: string) {
+          calls++;
+          expect(arguments).toHaveLength(2);
+          expect(file.originalFilename).toBe("notes.csv");
+          expect(id).toBe("07");
+          expect(this.parseImportFile).toBe(parseImportFile);
+          expect(this.tableName).toBe("fruits");
+          expect(events).toEqual([]);
+          return records;
+        };
+        const config = panelConfig({ tableName: "fruits", parseImportFile,
+          createConfig: { label: "Fruit", recordIdKey: "ownerId", columns: [] } });
+        await request(buildAppForManager(harness.manager, config)).post("/api/subrecordsImport")
+          .field("viewIndex", "0").field("panelIndex", "0").field("recordId", "07")
+          .attach("data", Buffer.from("csv"), "notes.csv")
+          .expect(harness.dbType === "POSTGRESQL" ? 500 : 200);
+        expect(calls).toBe(1);
+        expect(iterations).toBe(2);
+        expect(records[0]).toBe(first);
+        expect(first.note).toBe(note);
+        expect(events).toEqual(["serialize", "name", "inherited"]);
+        const { rows } = await harness.query("SELECT id, fruitName, acidity, note, age, slug, ownerId FROM fruits ORDER BY id");
+        expect(rows).toEqual(harness.dbType === "POSTGRESQL" ? [] : [
+          { id: 1, fruitName: "pomme d'hiver", acidity: 0, note: '{"ripe":true}', age: null, slug: "inherited", ownerId: 7 },
+          { id: 2, fruitName: "poire", acidity: 4, note: null, age: null, slug: null, ownerId: 7 },
+        ]);
+      });
+
+      it.each(["date", "getter", "database"])("preserves the %s insertion error response", async (failure) => {
+        const date = new Date("2026-10-06T12:00:00.000Z");
+        let calls = 0;
+        date.toISOString = function () { expect(this).toBe(date); calls++; return Date.prototype.toISOString.call(this); };
+        const row = failure === "date" ? { text: date } : failure === "database" ? { missingColumn: "bad" } : {
+          get text() { calls++; throw new Error("field failure"); },
+        };
+        const config = panelConfig({ parseImportFile: async () => [row] });
+        const response = await postSubImport(buildAppForManager(harness.manager, config)).expect(500);
+        expect(response.body.message).toBe("Une erreur est survenue.");
+        expect(response.body).toHaveProperty("err");
+        expect(calls).toBe(failure === "database" ? 0 : 1);
+        expect((await harness.query("SELECT * FROM fruit_notes")).rows).toEqual([]);
+      });
+
+      const isolatedPanelParser = (parserCase: string): Promise<unknown> => new Promise((resolve, reject) => {
+        const child = fork(path.join(__dirname, "importParserChild.cjs"), [], {
+          env: { ...process.env, IMPORT_BACKEND: _backend, IMPORT_CASE: parserCase, IMPORT_ROUTE: "panel" },
+          stdio: ["ignore", "ignore", "pipe", "ipc"],
+        });
+        let result: unknown;
+        let errors = "";
+        child.stderr?.on("data", (chunk) => { errors += chunk.toString(); });
+        child.on("message", (message) => { result = message; });
+        child.on("error", reject);
+        child.on("exit", (code) => code === 0 ? resolve(result) : reject(new Error(errors || `Child exited ${code}`)));
+      });
+
+      it.each([["throw", "parser sync failure"], ["reject", "parser async failure"]])(
+        "preserves an unhandled panel parser %s outside the insertion catch", async (parserCase, message) => {
+          expect(await isolatedPanelParser(parserCase)).toEqual({ kind: "unhandled", message });
+          expect((await harness.query("SELECT * FROM fruit_notes")).rows).toEqual([]);
+        },
+      );
+
+      // Approved remediation: only these SANITIZATION expectations may fail on original source.
+      it.each(["null", "undefined"])("SANITIZATION: rejects panel top-level %s before insertion", async (parserCase) => {
+        expect(await isolatedPanelParser(parserCase)).toEqual({ kind: "response", status: 400, body: {} });
+        expect((await harness.query("SELECT * FROM fruit_notes")).rows).toEqual([]);
+      });
+
+      it("SANITIZATION: validates all panel row shapes before reading fields", async () => {
+        let reads = 0;
+        const first = { get text() { reads++; return "must not insert"; } };
+        const config = panelConfig({ parseImportFile: async () => [first, null] });
+        const res = await postSubImport(buildAppForManager(harness.manager, config));
+        const { rows } = await harness.query("SELECT * FROM fruit_notes");
+        expect({ status: res.status, reads, rows }).toEqual({ status: 400, reads: 0, rows: [] });
+      });
+
+      it.each([
+        ["object with empty length", () => ({ length: 0 })],
+        ["string result", () => "ab"],
+        ["number result", () => 17],
+        ["boolean result", () => true],
+        ["function result", () => function () {}],
+        ["string row", () => [{ text: "must not insert" }, "ab"]],
+        ["number row", () => [{ text: "must not insert" }, 17]],
+        ["boolean row", () => [{ text: "must not insert" }, true]],
+        ["null row", () => [{ text: "must not insert" }, null]],
+        ["undefined row", () => [{ text: "must not insert" }, undefined]],
+        ["array row", () => [{ text: "must not insert" }, []]],
+        ["function row", () => [{ text: "must not insert" }, function () {}]],
+        ["sparse hole", () => { const rows = [{ text: "must not insert" }]; rows.length = 2; return rows; }],
+      ])("SANITIZATION: rejects panel %s without partial insertion", async (_label, result) => {
+        const config = panelConfig({ parseImportFile: async () => result() });
+        const res = await postSubImport(buildAppForManager(harness.manager, config));
+        const { rows } = await harness.query("SELECT * FROM fruit_notes");
+        expect({ status: res.status, rows }).toEqual({ status: 400, rows: [] });
+      });
+
       it("bulk upserts panel records bound to the parent record", async () => {
         const config = panelConfig();
         const res = await postSubImport(

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

@@ -332,9 +332,11 @@ describeIntegration("config enrichment against real information_schema", () => {
       "SELECT * FROM information_schema.columns WHERE table_schema = ?",
       ["galadmin_test"],
     );
+    if (!Array.isArray(rows)) throw new Error("Expected a row set");
     const pri = rows.find(
       (r: any) => r.TABLE_NAME === "fruits" && r.COLUMN_KEY === "PRI",
     );
+    if (!("COLUMN_NAME" in pri)) throw new Error("Expected a schema row");
     expect(pri.COLUMN_NAME).toBe("id");
   });
 
@@ -357,8 +359,10 @@ describeIntegration("config enrichment against real information_schema", () => {
       ["public"],
     );
     if (err) throw err;
+    if (!Array.isArray(rows)) throw new Error("Expected a row set");
     expect(rows.length).toBeGreaterThan(0);
     const first = rows[0];
+    if (!("table_name" in first)) throw new Error("Expected a schema row");
     expect(first.TABLE_NAME).toBeUndefined();
     expect(first.table_name).toBeDefined();
     expect(first.column_key).toBeUndefined();

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

@@ -1,4 +1,5 @@
 import * as request from "supertest";
+import type { DatabaseRow } from "../../src/utils/dbManager";
 import { generateUniqueIdForObject } from "../../src/api";
 import { buildAppForManager } from "../helpers/app";
 import { baseConfig, fruitView, EDITOR, VIEWER } from "../helpers/fixtures";
@@ -100,7 +101,8 @@ describeIntegration("records routes against real databases", () => {
                 label: "Clients only",
                 tableName: "orders",
                 roles: ["client"],
-                filtersFromUser: (id) => `client_id = ${id}`,
+                filtersFromUser: (user: { role: string; userId?: string | number }) =>
+                  user.role === "root" ? "" : typeof user.userId === "number" ? `client_id = ${user.userId}` : "1 = 0",
                 columns: [{ label: "Id", name: "id" }],
               },
               fruitView({ primaryId: "id" }),
@@ -203,13 +205,14 @@ describeIntegration("records routes against real databases", () => {
         expect(res.body.records[0].fruitName).toBe("l'orange");
       });
 
-      it("merges view filters, client filters and filtersFromUser", async () => {
+      it("FILTER USER POLICY: merges view filters, client filters and filtersFromUser", async () => {
         const config = {
           views: [
             fruitView({
               primaryId: "id",
               filters: "acidity < 10",
-              filtersFromUser: (userId: number) => `ownerId = ${userId}`,
+              filtersFromUser: (user: { role: string; userId?: string | number }) =>
+                user.role === "root" ? "" : typeof user.userId === "number" ? `ownerId = ${user.userId}` : "1 = 0",
             }),
           ],
         };
@@ -438,13 +441,14 @@ describeIntegration("records routes against real databases", () => {
       // reachable on a healthy engine — when the wrapped query runs, its
       // COUNT(*) projection runs too — so it has no real-engine equivalent.
 
-      it("serves rows scoped per-user via filtersFromUser(userId, role)", async () => {
+      it("FILTER USER POLICY: serves rows scoped per-user via filtersFromUser(user)", async () => {
         const config = {
           views: [
             fruitView({
               primaryId: "id",
-              filtersFromUser: (userId: number, role?: string) =>
-                `ownerId = ${userId} AND role = '${role}'`,
+              filtersFromUser: (user: { role: string; userId?: string | number }) =>
+                user.role === "root" ? "" : typeof user.userId === "number"
+                  ? `ownerId = ${user.userId} AND role = '${user.role}'` : "1 = 0",
             }),
           ],
         };
@@ -503,9 +507,81 @@ describeIntegration("records routes against real databases", () => {
           .expect(200);
         expect(res.body).toEqual({ recordId: null });
       });
+
+      it("omits recordId when the selected row lacks the requested column", async () => {
+        const res = await request(app())
+          .post("/api/adjacentRecordId")
+          .send({
+            position: "1", offset: "0", primaryId: "missing", table: "fruits",
+            customQuery: "SELECT 1 AS id",
+          })
+          .expect(200);
+        expect(res.body).toEqual({});
+      });
+
+      it("preserves a null value in the requested column", async () => {
+        const res = await request(app())
+          .post("/api/adjacentRecordId")
+          .send({
+            position: "1", offset: "0", primaryId: "id", table: "fruits",
+            customQuery: "SELECT NULL AS id",
+          })
+          .expect(200);
+        expect(res.body).toEqual({ recordId: null });
+      });
+
+      it.each([
+        ["SELECT 1 AS id", {}],
+        ["SELECT 17 AS undefined", { recordId: 17 }],
+      ])("preserves omitted primaryId for %s", async (customQuery, expected) => {
+        const res = await request(app())
+          .post("/api/adjacentRecordId")
+          .send({ position: "1", offset: "0", table: "fruits", customQuery })
+          .expect(200);
+        expect(res.body).toEqual(expected);
+      });
+
+      it("returns the database error with HTTP 500", async () => {
+        const res = await request(app())
+          .post("/api/adjacentRecordId")
+          .send({ position: "1", offset: "0", primaryId: "id", table: "port_missing_table" })
+          .expect(500);
+        expect(res.body.code).toBe(_backend === "postgresql" ? "42P01" : "ER_NO_SUCH_TABLE");
+        expect(res.body).not.toHaveProperty("recordId");
+      });
     });
 
     describe("GET /api/record", () => {
+      it("awaits formatters in order with shared record identity, receivers and missing column ids", async () => {
+        expect((await harness.query("INSERT INTO fruits (fruitName) VALUES (?)", ["pomme"])).err).toBeFalsy();
+        const seenRows: DatabaseRow[] = [];
+        const config = baseConfig({ enriched: true, views: [fruitView({
+          primaryId: "id",
+          columns: [
+            {
+              label: "First", name: "fruitName",
+              async formatValue(this: { label: string }, row: DatabaseRow) {
+                seenRows.push(row);
+                return `${this.label}:${row.fruitName}`;
+              },
+            },
+            {
+              label: "Second", name: "acidity",
+              async formatValue(this: { label: string }, row: DatabaseRow) {
+                seenRows.push(row);
+                return `${row["__formatValue-undefined__"]}:${this.label}`;
+              },
+            },
+          ],
+        })] });
+        const result = await request(buildAppForManager(harness.manager, config))
+          .get("/api/record").query({ viewIndex: "0", recordId: "1" }).expect(200);
+        expect(result.body["__formatValue-undefined__"]).toBe("First:pomme:Second");
+        expect(result.body.fruitName).toBe("pomme");
+        expect(seenRows).toHaveLength(2);
+        expect(seenRows[0]).toBe(seenRows[1]);
+      });
+
       it("returns a single record by primary id", async () => {
         const instance = app();
         await request(instance)