@saltcorn/server 1.6.0-rc.1 → 1.6.0-rc.3

package/tests/sync-upload-data.test.js

@@ -0,0 +1,164 @@
+const {
+  kahnSort,
+  orderCycleTables,
+} = require("../../saltcorn-cli/src/commands/sync-upload-data");
+
+const fks = (map) => (tblName) =>
+  (map[tblName] || []).map((ref) => ({ reftable_name: ref }));
+
+const flat = (changes, fkMap) => {
+  const { sorted, cycleTables } = kahnSort(changes, fks(fkMap));
+  return [...sorted, ...cycleTables];
+};
+
+describe("kahnSort", () => {
+  test("single table is returned as-is", () => {
+    const { sorted, cycleTables } = kahnSort({ books: {} }, fks({}));
+    expect(sorted).toEqual(["books"]);
+    expect(cycleTables).toEqual([]);
+  });
+
+  test("two independent tables are both returned", () => {
+    const result = flat({ books: {}, authors: {} }, {});
+    expect(result).toHaveLength(2);
+    expect(result).toContain("books");
+    expect(result).toContain("authors");
+  });
+
+  test("parent comes before child", () => {
+    const result = flat(
+      { books: {}, publishers: {} },
+      { books: ["publishers"] }
+    );
+    expect(result.indexOf("publishers")).toBeLessThan(result.indexOf("books"));
+  });
+
+  test("three-level chain is ordered correctly", () => {
+    // chapters -> books -> publishers
+    const result = flat(
+      { chapters: {}, books: {}, publishers: {} },
+      { chapters: ["books"], books: ["publishers"] }
+    );
+    expect(result.indexOf("publishers")).toBeLessThan(result.indexOf("books"));
+    expect(result.indexOf("books")).toBeLessThan(result.indexOf("chapters"));
+  });
+
+  test("diamond dependency: shared parent comes first, shared child comes last", () => {
+    // both b and c depend on a; d depends on both b and c
+    const result = flat(
+      { a: {}, b: {}, c: {}, d: {} },
+      { b: ["a"], c: ["a"], d: ["b", "c"] }
+    );
+    expect(result.indexOf("a")).toBeLessThan(result.indexOf("b"));
+    expect(result.indexOf("a")).toBeLessThan(result.indexOf("c"));
+    expect(result.indexOf("b")).toBeLessThan(result.indexOf("d"));
+    expect(result.indexOf("c")).toBeLessThan(result.indexOf("d"));
+  });
+
+  test("FK to a table not in changes is ignored", () => {
+    const result = flat({ books: {} }, { books: ["external_table"] });
+    expect(result).toEqual(["books"]);
+  });
+
+  test("self-referencing FK does not affect order", () => {
+    const result = flat({ categories: {} }, { categories: ["categories"] });
+    expect(result).toEqual(["categories"]);
+  });
+
+  test("cyclic dependency: cycle tables are separated out", () => {
+    const { sorted, cycleTables } = kahnSort(
+      { a: {}, b: {} },
+      fks({ a: ["b"], b: ["a"] })
+    );
+    expect(sorted).toHaveLength(0);
+    expect(cycleTables).toHaveLength(2);
+    expect(cycleTables).toContain("a");
+    expect(cycleTables).toContain("b");
+  });
+
+  test("multiple FKs to the same parent table", () => {
+    const result = flat(
+      { books: {}, publishers: {} },
+      { books: ["publishers", "publishers"] }
+    );
+    expect(result.indexOf("publishers")).toBeLessThan(result.indexOf("books"));
+    expect(result).toHaveLength(2);
+    expect(new Set(result).size).toBe(2);
+  });
+
+  test("all tables appear exactly once", () => {
+    const result = flat(
+      { a: {}, b: {}, c: {}, d: {} },
+      { b: ["a"], c: ["a"], d: ["b", "c"] }
+    );
+    expect(result).toHaveLength(4);
+    expect(new Set(result).size).toBe(4);
+  });
+});
+
+// Mock a table with FK fields: [{ field, ref, required? }]
+const mockTable = (fkSpecs) => ({
+  getFields: () =>
+    fkSpecs.map(({ field, required = false }) => ({ name: field, required })),
+  getForeignKeys: () =>
+    fkSpecs.map(({ field, ref }) => ({ name: field, reftable_name: ref })),
+});
+const makeGetTable = (specs) => (name) => {
+  const s = specs[name];
+  return s ? mockTable(s) : null;
+};
+
+describe("orderCycleTables", () => {
+  test("nullable side inserted before required side", () => {
+    // A.b_ref -> B (required), B.a_ref -> A (nullable)
+    const getTable = makeGetTable({
+      A: [{ field: "b_ref", ref: "B", required: true }],
+      B: [{ field: "a_ref", ref: "A", required: false }],
+    });
+    const { cycleOrder, deferFields } = orderCycleTables(["A", "B"], getTable);
+    expect(cycleOrder[0]).toBe("B");
+    expect(cycleOrder[1]).toBe("A");
+  });
+
+  test("nullable FK field is deferred for the first-inserted table", () => {
+    const getTable = makeGetTable({
+      A: [{ field: "b_ref", ref: "B", required: true }],
+      B: [{ field: "a_ref", ref: "A", required: false }],
+    });
+    const { deferFields } = orderCycleTables(["A", "B"], getTable);
+    expect(deferFields.get("B")).toEqual(new Set(["a_ref"]));
+    expect(deferFields.has("A")).toBe(false);
+  });
+
+  test("required FK field is never deferred", () => {
+    const getTable = makeGetTable({
+      A: [{ field: "b_ref", ref: "B", required: true }],
+      B: [{ field: "a_ref", ref: "A", required: false }],
+    });
+    const { deferFields } = orderCycleTables(["A", "B"], getTable);
+    expect(deferFields.has("A")).toBe(false);
+  });
+
+  test("both nullable: first table has its FK deferred, second does not", () => {
+    const getTable = makeGetTable({
+      A: [{ field: "b_ref", ref: "B", required: false }],
+      B: [{ field: "a_ref", ref: "A", required: false }],
+    });
+    const { cycleOrder, deferFields } = orderCycleTables(["A", "B"], getTable);
+    expect(cycleOrder).toHaveLength(2);
+    // Only the first-inserted table needs deferral; the second can translate normally.
+    expect(deferFields.size).toBe(1);
+    expect(deferFields.has(cycleOrder[0])).toBe(true);
+    expect(deferFields.has(cycleOrder[1])).toBe(false);
+  });
+
+  test("all cycle tables appear in cycleOrder exactly once", () => {
+    const getTable = makeGetTable({
+      A: [{ field: "b_ref", ref: "B", required: true }],
+      B: [{ field: "a_ref", ref: "A", required: false }],
+    });
+    const { cycleOrder } = orderCycleTables(["A", "B"], getTable);
+    expect(cycleOrder).toHaveLength(2);
+    expect(new Set(cycleOrder).size).toBe(2);
+  });
+});

package/tests/sync.test.js

@@ -767,7 +767,7 @@ describe("Upload changes", () => {
       const error = await getResult(app, loginCookie, syncDir);
       await cleanSyncDir(app, loginCookie, syncDir);
       expect(error).toBeDefined();
-      expect(error).toEqual({ message: "Unable to insert into books" });
+      expect(error).toEqual({ message: "Unable to insert into publisher" });
       books.min_role_write = 100;
       await books.update(books);
     });
@@ -1766,6 +1766,233 @@ describe("load_changes authorization with ownership_formula", () => {
     });
 });
 
+describe("cross-table FK translation during inserts", () => {
+  if (!db.isSQLite) {
+    beforeAll(async () => {
+      await initSyncInfo(["books", "publisher"]);
+    });
+
+    it("FK is translated when child is listed before parent in changes", async () => {
+      const oldTimestamp = new Date().valueOf();
+      const app = await getApp({ disableCsrf: true });
+      const loginCookie = await getAdminLoginCookie();
+
+      // Use IDs far above any existing server IDs so FK cannot be satisfied
+      // by an already-existing row — only the topo-ordered insert of publisher
+      // first makes this work.
+      const maxPublId = await maxId("publisher");
+      const maxBookId = await maxId("books");
+      const localPublisherId = maxPublId + 100;
+      const localBookId = maxBookId + 100;
+
+      // Deliberately list books (child) before publisher (parent) in the payload.
+      const resp = await doUpload(
+        app,
+        loginCookie,
+        new Date().valueOf(),
+        oldTimestamp,
+        {
+          books: {
+            inserts: [
+              {
+                id: localBookId,
+                author: "Cross FK Author",
+                pages: 77,
+                publisher: localPublisherId,
+              },
+            ],
+          },
+          publisher: {
+            inserts: [{ id: localPublisherId, name: "Cross FK Publisher" }],
+          },
+        }
+      );
+      expect(resp.status).toBe(200);
+      const { syncDir } = resp._body;
+      const result = await getResult(app, loginCookie, syncDir);
+      await cleanSyncDir(app, loginCookie, syncDir);
+
+      expect(result.translatedIds).toBeDefined();
+      const serverPublisherId =
+        result.translatedIds.publisher?.[localPublisherId];
+      const serverBookId = result.translatedIds.books?.[localBookId];
+      expect(serverPublisherId).toBeDefined();
+      expect(serverBookId).toBeDefined();
+
+      // The inserted book must reference the new server publisher ID, not the
+      // original local one.
+      const books = Table.findOne({ name: "books" });
+      const insertedBook = await books.getRow({ id: serverBookId });
+      expect(insertedBook).toBeDefined();
+      expect(insertedBook.publisher).toBe(serverPublisherId);
+    });
+
+    it("FK translation works regardless of key order in changes object", async () => {
+      const oldTimestamp = new Date().valueOf();
+      const app = await getApp({ disableCsrf: true });
+      const loginCookie = await getAdminLoginCookie();
+
+      const maxPublId = await maxId("publisher");
+      const maxBookId = await maxId("books");
+      const localPublisherId = maxPublId + 100;
+      const localBookId = maxBookId + 100;
+
+      // This time publisher is listed first — result should be identical.
+      const resp = await doUpload(
+        app,
+        loginCookie,
+        new Date().valueOf(),
+        oldTimestamp,
+        {
+          publisher: {
+            inserts: [{ id: localPublisherId, name: "Cross FK Publisher 2" }],
+          },
+          books: {
+            inserts: [
+              {
+                id: localBookId,
+                author: "Cross FK Author 2",
+                pages: 88,
+                publisher: localPublisherId,
+              },
+            ],
+          },
+        }
+      );
+      expect(resp.status).toBe(200);
+      const { syncDir } = resp._body;
+      const result = await getResult(app, loginCookie, syncDir);
+      await cleanSyncDir(app, loginCookie, syncDir);
+
+      const serverPublisherId =
+        result.translatedIds.publisher?.[localPublisherId];
+      const serverBookId = result.translatedIds.books?.[localBookId];
+      expect(serverPublisherId).toBeDefined();
+      expect(serverBookId).toBeDefined();
+
+      const books = Table.findOne({ name: "books" });
+      const insertedBook = await books.getRow({ id: serverBookId });
+      expect(insertedBook.publisher).toBe(serverPublisherId);
+    });
+  } else
+    it("only pq support", () => {
+      expect(true).toBe(true);
+    });
+});
+
+describe("cyclic FK insert via sync", () => {
+  if (!db.isSQLite) {
+    let tableA, tableB;
+
+    beforeAll(async () => {
+      await resetToFixtures();
+
+      // tableA.b_ref -> tableB (required), tableB.a_ref -> tableA (nullable)
+      tableA = await Table.create("sync_cycle_a", {
+        min_role_read: 100,
+        min_role_write: 100,
+      });
+      await Field.create({
+        table: tableA,
+        name: "name",
+        label: "Name",
+        type: "String",
+      });
+
+      tableB = await Table.create("sync_cycle_b", {
+        min_role_read: 100,
+        min_role_write: 100,
+      });
+      await Field.create({
+        table: tableB,
+        name: "name",
+        label: "Name",
+        type: "String",
+      });
+
+      await Field.create({
+        table: tableA,
+        name: "b_ref",
+        label: "B ref",
+        type: "Key",
+        reftable: tableB,
+        attributes: { summary_field: "name" },
+        required: true,
+      });
+      await Field.create({
+        table: tableB,
+        name: "a_ref",
+        label: "A ref",
+        type: "Key",
+        reftable: tableA,
+        attributes: { summary_field: "name" },
+        required: false,
+      });
+
+      await initSyncInfo(["sync_cycle_a", "sync_cycle_b"]);
+      tableA = Table.findOne({ name: "sync_cycle_a" });
+      tableB = Table.findOne({ name: "sync_cycle_b" });
+    });
+
+    afterAll(async () => {
+      // Break the cycle by dropping A's FK to B first, then B can be dropped,
+      // then A.
+      const freshA = Table.findOne({ name: "sync_cycle_a" });
+      const bRefField = freshA?.getFields().find((f) => f.name === "b_ref");
+      if (bRefField) await bRefField.delete();
+      if (tableB) await tableB.delete();
+      if (tableA) await tableA.delete();
+    });
+
+    it("inserts both cyclic rows with FKs correctly resolved", async () => {
+      const oldTimestamp = new Date().valueOf();
+      const app = await getApp({ disableCsrf: true });
+      const loginCookie = await getAdminLoginCookie();
+
+      const localAId = 9001;
+      const localBId = 9002;
+
+      // Submit A before B so that without topo/cycle handling this would fail:
+      // A.b_ref points to a B row that doesn't exist on the server yet.
+      const resp = await doUpload(
+        app,
+        loginCookie,
+        new Date().valueOf(),
+        oldTimestamp,
+        {
+          sync_cycle_a: {
+            inserts: [{ id: localAId, name: "row A", b_ref: localBId }],
+          },
+          sync_cycle_b: {
+            inserts: [{ id: localBId, name: "row B", a_ref: localAId }],
+          },
+        }
+      );
+      expect(resp.status).toBe(200);
+      const { syncDir } = resp._body;
+      const result = await getResult(app, loginCookie, syncDir);
+      await cleanSyncDir(app, loginCookie, syncDir);
+
+      expect(result.translatedIds).toBeDefined();
+      const serverAId = result.translatedIds.sync_cycle_a?.[localAId];
+      const serverBId = result.translatedIds.sync_cycle_b?.[localBId];
+      expect(serverAId).toBeDefined();
+      expect(serverBId).toBeDefined();
+
+      // A.b_ref must point to the server-assigned B ID
+      const rowA = await tableA.getRow({ id: serverAId });
+      expect(rowA.b_ref).toBe(serverBId);
+
+      // B.a_ref must point to the server-assigned A ID (deferred post-UPDATE)
+      const rowB = await tableB.getRow({ id: serverBId });
+      expect(rowB.a_ref).toBe(serverAId);
+    });
+  } else
+    it("only pq support", () => {
+      expect(true).toBe(true);
+    });
+});
+
 describe("sync dir email suffix attack", () => {
   if (!db.isSQLite) {
     beforeAll(async () => {