@saltcorn/builder 0.9.4-beta.1 → 0.9.4-beta.10

package/src/components/elements/utils.js

@@ -18,6 +18,7 @@ import FontIconPicker from "@fonticonpicker/react-fonticonpicker";
 import faIcons from "./faicons";
 import { Columns, ntimes } from "./Columns";
 import Tippy from "@tippyjs/react";
+import { RelationType } from "@saltcorn/common-code";
 
 export const DynamicFontAwesomeIcon = ({ icon, className }) => {
   if (!icon) return null;
@@ -445,6 +446,10 @@ const fetchPreview = ({ url, body, options, setPreviews, node_id, isView }) => {
       }
       const newHtml = $(".preview-scratchpad").html();
       setPreviews((prevState) => ({ ...prevState, [node_id]: newHtml }));
+    })
+    .catch((e) => {
+      console.log("Unable to fetch the preview:");
+      console.log(e);
     });
 };
 
@@ -1245,12 +1250,20 @@ const ButtonOrLinkSettingsRows = ({
           <option value={addBtnClass("btn-secondary")}>Secondary button</option>
           <option value={addBtnClass("btn-success")}>Success button</option>
           <option value={addBtnClass("btn-danger")}>Danger button</option>
+          <option value={addBtnClass("btn-warning")}>Warning button</option>
+          <option value={addBtnClass("btn-info")}>Info button</option>
           <option value={addBtnClass("btn-outline-primary")}>
             Primary outline button
           </option>
           <option value={addBtnClass("btn-outline-secondary")}>
             Secondary outline button
           </option>
+          <option value={addBtnClass("btn-outline-warning")}>
+            Warning outline button
+          </option>{" "}
+          <option value={addBtnClass("btn-outline-info")}>
+            Info outline button
+          </option>
           <option value={addBtnClass("btn-custom-color")}>
             Button custom color
           </option>
@@ -1439,22 +1452,6 @@ const Tooltip = ({ children }) => {
   );
 };
 
-export const buildTableCaches = (allTables) => {
-  const tableIdCache = {};
-  const tableNameCache = {};
-  const fieldCache = {};
-  for (const table of allTables) {
-    tableIdCache[table.id] = table;
-    tableNameCache[table.name] = table;
-    for (const field of table.foreign_keys) {
-      if (!fieldCache[field.reftable_name])
-        fieldCache[field.reftable_name] = [];
-      fieldCache[field.reftable_name].push(field);
-    }
-  }
-  return { tableIdCache, tableNameCache, fieldCache };
-};
-
 export const removeWhitespaces = (str) => {
   return str.replace(/\s/g, "X");
 };
@@ -1497,79 +1494,145 @@ export const buildBootstrapOptions = (values) => {
   ));
 };
 
-export const prepCacheAndFinder = ({
-  tables,
-  views,
-  max_relations_layer_depth,
-}) => {
-  if (tables && views) {
-    const caches = buildTableCaches(tables);
-    const finder = new relationHelpers.RelationsFinder(
-      caches,
-      views,
-      max_relations_layer_depth || 6
-    );
-    return { caches, finder };
-  } else return { caches: null, finder: null };
+export const arrayChunks = (xs, n) => {
+  const arrayOfArrays = [];
+  for (var i = 0; i < bigarray.length; i += n) {
+    arrayOfArrays.push(bigarray.slice(i, i + n));
+  }
+  return arrayOfArrays;
 };
 
 /**
- * @param {string[]} paths
+ * @param {string[]} relations
  * @param {string} sourceTbl name of the topview table
  * @returns either a same table relation, a parent relation, a child relation, or the first relation
  */
-export const initialRelation = (paths, sourceTbl) => {
+export const initialRelation = (relations) => {
   let sameTblRel = null;
   let parentRel = null;
   let childRel = null;
-  for (const path of paths) {
-    if (!sameTblRel && path === `.${sourceTbl}`) sameTblRel = path;
-    else {
-      const tokens = path.split(".");
-      if (
-        !parentRel &&
-        tokens.length === 3 &&
-        tokens[1] === sourceTbl &&
-        tokens[2].indexOf("$") === -1
-      )
-        parentRel = path;
-      else {
-        const lastToken = tokens[tokens.length - 1];
-        if (
-          lastToken.indexOf("$") > 0 &&
-          (!childRel || childRel.split(".").length > tokens.length)
-        )
-          childRel = path;
-      }
+  for (const relation of relations) {
+    switch (relation.type) {
+      case RelationType.OWN:
+        sameTblRel = relation;
+        break;
+      case RelationType.PARENT_SHOW:
+        parentRel = relation;
+        break;
+      case RelationType.CHILD_LIST:
+      case RelationType.ONE_TO_ONE_SHOW:
+        childRel = relation;
+        break;
     }
   }
-  return sameTblRel || parentRel || childRel || paths[0];
+  return sameTblRel || parentRel || childRel || relations[0];
 };
 
 /**
- * update the builder wide relations cache relations cache
- * if there is no entry for the given tableName and viewname
- * @param {any} relationsCache cache from the context
- * @param {Function} setRelationsCache set cache in context
- * @param {any} options builder options
- * @param {RelationsFinder} finder
- * @param {string} viewname subview name
+ * builder intern path method
+ * @param path
+ * @param tableNameCache
+ * @returns
  */
-export const updateRelationsCache = (
-  relationsCache,
-  setRelationsCache,
-  options,
-  finder,
-  viewname
-) => {
-  if (!relationsCache[options.tableName])
-    relationsCache[options.tableName] = {};
-  if (!relationsCache[options.tableName][viewname]) {
-    relationsCache[options.tableName][viewname] = finder.findRelations(
-      options.tableName,
-      viewname,
-      options.excluded_subview_templates
-    );
-    setRelationsCache({ ...relationsCache });
+export const buildRelationArray = (path, tableNameCache) => {
+  if (path === ".")
+    return [{ type: "Independent", table: "None (no relation)" }];
+  const tokens = path.split(".");
+  if (tokens.length === 2)
+    return [{ type: "Own", table: `${tokens[1]} (same table)` }];
+  else if (tokens.length >= 3) {
+    const result = [];
+    let currentTbl = tokens[1];
+    for (const relation of tokens.slice(2)) {
+      if (relation.indexOf("$") > 0) {
+        const [inboundTbl, inboundKey] = relation.split("$");
+        result.push({ type: "Inbound", table: inboundTbl, key: inboundKey });
+        currentTbl = inboundTbl;
+      } else {
+        const srcTbl = tableNameCache[currentTbl];
+        const fk = srcTbl.foreign_keys.find((fk) => fk.name === relation);
+        if (fk) {
+          const targetTbl = tableNameCache[fk.reftable_name];
+          result.push({
+            type: "Foreign",
+            table: targetTbl.name,
+            key: relation,
+          });
+          currentTbl = targetTbl.name;
+        }
+      }
+    }
+    return result;
+  }
+};
+
+export const buildLayers = (relations, tableName, tableNameCache) => {
+  const result = { table: tableName, inboundKeys: [], fkeys: [] };
+  for (const relation of relations) {
+    const relType = relation.type;
+    let currentLevel = result;
+    if (relType === RelationType.INDEPENDENT) {
+      currentLevel.fkeys.push({
+        name: "none (no relation)",
+        table: "",
+        inboundKeys: [],
+        fkeys: [],
+        relPath: relation.relationString,
+      });
+    } else if (relType === RelationType.OWN) {
+      currentLevel.fkeys.push({
+        name: "same table",
+        table: relation.targetTblName,
+        inboundKeys: [],
+        fkeys: [],
+        relPath: relation.relationString,
+      });
+    } else {
+      let currentTbl = relation.sourceTblName;
+      for (const pathElement of relation.path) {
+        if (pathElement.inboundKey) {
+          currentTbl = pathElement.table;
+          const existing = currentLevel.inboundKeys.find(
+            (key) =>
+              key.name === pathElement.inboundKey && key.table === currentTbl
+          );
+          if (existing) {
+            currentLevel = existing;
+          } else {
+            const nextLevel = {
+              name: pathElement.inboundKey,
+              table: currentTbl,
+              inboundKeys: [],
+              fkeys: [],
+            };
+            currentLevel.inboundKeys.push(nextLevel);
+            currentLevel = nextLevel;
+          }
+        } else if (pathElement.fkey) {
+          const tblObj = tableNameCache[currentTbl];
+          const fkey = tblObj.foreign_keys.find(
+            (key) => key.name === pathElement.fkey
+          );
+          currentTbl = fkey.reftable_name;
+          const existing = currentLevel.fkeys.find(
+            (key) => key.name === pathElement.fkey
+          );
+          if (existing) {
+            currentLevel = existing;
+          } else {
+            const nextLevel = {
+              name: pathElement.fkey,
+              table: currentTbl,
+              inboundKeys: [],
+              fkeys: [],
+            };
+            currentLevel.fkeys.push(nextLevel);
+            currentLevel = nextLevel;
+          }
+        }
+      }
+    }
+    currentLevel.relPath = relation.relationString;
   }
+  return result;
 };

package/src/components/storage.js

@@ -253,6 +253,7 @@ const layoutToNodes = (layout, query, actions, parent = "ROOT") => {
         <Tabs
           key={ix}
           titles={segment.titles}
+          showif={segment.showif}
           ntabs={segment.ntabs}
           independent={segment.independent}
           startClosed={segment.startClosed}
@@ -529,6 +530,7 @@ const craftToSaltcorn = (nodes, startFrom = "ROOT") => {
         type: "tabs",
         contents,
         titles: node.props.titles,
+        showif: node.props.showif,
         tabsStyle: node.props.tabsStyle,
         field: node.props.field,
         independent: node.props.independent,

package/tests/relations_finder.test.js

@@ -9,7 +9,16 @@ import {
   withKeyFromLayerTwo,
   withKeyFromLayerThree,
   withSimplePostTopicrelation,
-} from "./test_data";
+} from "@saltcorn/common-code/tests/test_data";
+
+import {
+  expectedOne,
+  expectedTwo,
+  expectedThree,
+  expectedFour,
+  expectedFive,
+  expectedSix,
+} from "@saltcorn/common-code/tests/expected_relations";
 import { ViewSettings } from "../src/components/elements/View";
 import { ViewLinkSettings } from "../src/components/elements/ViewLink";
 
@@ -60,43 +69,47 @@ const doTest = (
   renderer.create(<ViewSettings></ViewSettings>);
   expect(spy).toBeCalled();
   const vCallArgs = spy.mock.calls[0];
-  expect(vCallArgs[0].paths).toBeDefined();
-  expect(vCallArgs[0].paths).toHaveLength(expected.length);
-  expect(vCallArgs[0].paths).toEqual(expect.arrayContaining(expected));
+  expect(vCallArgs[0].relations).toBeDefined();
+  expect(vCallArgs[0].relations).toHaveLength(expected.length);
+  expect(vCallArgs[0].relations.map((rel) => rel.relationString)).toEqual(
+    expect.arrayContaining(expected)
+  );
 
   renderer.create(<ViewLinkSettings></ViewLinkSettings>);
   expect(spy.mock.calls).toHaveLength(4);
   const vLinkcallArgs = spy.mock.calls[2];
-  expect(vLinkcallArgs[0].paths).toBeDefined();
-  expect(vLinkcallArgs[0].paths).toHaveLength(expected.length);
-  expect(vLinkcallArgs[0].paths).toEqual(expect.arrayContaining(expected));
+  expect(vLinkcallArgs[0].relations).toBeDefined();
+  expect(vLinkcallArgs[0].relations).toHaveLength(expected.length);
+  expect(vLinkcallArgs[0].relations.map((rel) => rel.relationString)).toEqual(
+    expect.arrayContaining(expected)
+  );
 };
 
 describe("relations tests", () => {
-  beforeAll(() => {
-    // inject relationHelpers (normally it's a script tag)
-    global.relationHelpers = {
-      ...require("../../server/public/relation_helpers.js"),
-    };
-  });
   beforeEach(() => {
     jest.restoreAllMocks();
   });
   describe("single relations", () => {
-    it("parent relations", async () => {
-      const { tables, views } = fixturesData();
+    it("parent relations", () => {
+      const { tables, views } = fixturesData(__dirname);
       const expected = [".fan_club.artist"];
       doTest(tables, views, "fan_club", "show_artist", expected);
     });
 
-    it("one to one relations", async () => {
-      const { tables, views } = fixturesData();
+    it("parent relations with layers", () => {
+      const { tables, views } = fixturesData(__dirname);
+      const expected = [".patients.favbook.publisher"];
+      doTest(tables, views, "patients", "show_publisher", expected);
+    });
+
+    it("one to one relations", () => {
+      const { tables, views } = fixturesData(__dirname);
       const expected = [".covers.albums$cover"];
       doTest(tables, views, "covers", "show_album", expected);
     });
 
-    it("employee department relation", async () => {
-      const { tables, views } = fixturesData();
+    it("employee department relation", () => {
+      const { tables, views } = fixturesData(__dirname);
       const expected = [".employee", ".employee.department.manager"];
       doTest(tables, views, "employee", "show_manager", expected);
     });
@@ -104,85 +117,37 @@ describe("relations tests", () => {
 
   describe("multi relations", () => {
     describe("inbound relations", () => {
-      const expectedOne = [
-        ".",
-        ".users.user_interested_in_topic$user.topic.blog_in_topic$topic",
-        ".users.user_interested_in_topic$user.topic.inbound_inbound$topic.bp_inbound.post.blog_in_topic$post",
-        ".users.messages$user.room.participants$room.user.user_interested_in_topic$user.topic.blog_in_topic$topic",
-      ];
-      it("single keys to source and rel table", async () => {
-        const { tables, views } = fixturesData();
+      it("single keys to source and rel table", () => {
+        const { tables, views } = fixturesData(__dirname);
         doTest(tables, views, "users", "blog_in_topic_feed", expectedOne);
       });
 
-      const expectedTwo = [
-        ...expectedOne,
-        ".users.user_interested_in_topic$another_user.topic.blog_in_topic$topic",
-        ".users.user_interested_in_topic$another_user.topic.inbound_inbound$topic.bp_inbound.post.blog_in_topic$post",
-        ".users.messages$user.room.participants$room.user.user_interested_in_topic$another_user.topic.blog_in_topic$topic",
-      ];
-      it("multiple keys to source and single key to rel table", async () => {
-        const { tables, views } = withAnotherUserField();
+      it("multiple keys to source and single key to rel table", () => {
+        const { tables, views } = withAnotherUserField(__dirname);
         doTest(tables, views, "users", "blog_in_topic_feed", expectedTwo);
       });
 
-      const expectedThree = [
-        ...expectedTwo,
-        ".users.user_interested_in_topic$user.topic.blog_in_topic$second_topic",
-        ".users.user_interested_in_topic$another_user.topic.blog_in_topic$second_topic",
-        ".users.messages$user.room.participants$room.user.user_interested_in_topic$user.topic.blog_in_topic$second_topic",
-        ".users.messages$user.room.participants$room.user.user_interested_in_topic$another_user.topic.blog_in_topic$second_topic",
-      ];
-      it("multiple keys to source and rel table", async () => {
-        const { tables, views } = withSecondTopicField();
+      it("multiple keys to source and rel table", () => {
+        const { tables, views } = withSecondTopicField(__dirname);
         doTest(tables, views, "users", "blog_in_topic_feed", expectedThree);
       });
 
-      const expectedFour = [
-        ...expectedThree,
-        ".users.user_interested_in_topic$user.another_user.second_inbound$user.topic.blog_in_topic$topic",
-        ".users.user_interested_in_topic$user.another_user.second_inbound$user.topic.blog_in_topic$second_topic",
-        ".users.second_inbound$user.topic.blog_in_topic$topic",
-        ".users.second_inbound$user.topic.blog_in_topic$second_topic",
-        ".users.second_inbound$user.topic.inbound_inbound$topic.bp_inbound.post.blog_in_topic$post",
-        ".users.messages$user.room.participants$room.user.second_inbound$user.topic.blog_in_topic$topic",
-        ".users.messages$user.room.participants$room.user.second_inbound$user.topic.blog_in_topic$second_topic",
-      ];
-      it("multiple inbound tables", async () => {
-        const { tables, views } = withMultipleInbounds();
+      it("multiple inbound tables", () => {
+        const { tables, views } = withMultipleInbounds(__dirname);
         doTest(tables, views, "users", "blog_in_topic_feed", expectedFour);
       });
 
-      const expectedFive = [
-        ...expectedFour,
-        ".users.user_interested_in_topic$user.topic.inbound_inbound$topic.post_from_layer_two.blog_in_topic$post",
-        ".users.user_interested_in_topic$another_user.topic.inbound_inbound$topic.post_from_layer_two.blog_in_topic$post",
-        ".users.second_inbound$user.topic.inbound_inbound$topic.post_from_layer_two.blog_in_topic$post",
-        ".users.user_interested_in_topic$user.topic.blog_in_topic$topic.post.inbound_inbound$post_from_layer_two.topic.blog_in_topic$second_topic",
-        ".users.user_interested_in_topic$user.another_user.second_inbound$user.topic.inbound_inbound$topic.post_from_layer_two.blog_in_topic$post",
-        ".users.user_interested_in_topic$another_user.topic.blog_in_topic$topic.post.inbound_inbound$post_from_layer_two.topic.blog_in_topic$second_topic",
-        ".users.second_inbound$user.topic.blog_in_topic$topic.post.inbound_inbound$post_from_layer_two.topic.blog_in_topic$second_topic",
-      ];
-      it("key to source from layer two", async () => {
-        const { tables, views } = withKeyFromLayerTwo();
+      it("key to source from layer two", () => {
+        const { tables, views } = withKeyFromLayerTwo(__dirname);
         doTest(tables, views, "users", "blog_in_topic_feed", expectedFive);
       });
 
-      const expectedSix = [
-        ...expectedFive,
-        ".users.user_interested_in_topic$user.topic.inbound_level_three$topic.inbound_level_two.bp_inbound.post.blog_in_topic$post",
-        ".users.user_interested_in_topic$user.topic.inbound_level_three$topic.inbound_level_two.post_from_layer_two.blog_in_topic$post",
-        ".users.user_interested_in_topic$another_user.topic.inbound_level_three$topic.inbound_level_two.bp_inbound.post.blog_in_topic$post",
-        ".users.user_interested_in_topic$another_user.topic.inbound_level_three$topic.inbound_level_two.post_from_layer_two.blog_in_topic$post",
-        ".users.second_inbound$user.topic.inbound_level_three$topic.inbound_level_two.bp_inbound.post.blog_in_topic$post",
-        ".users.second_inbound$user.topic.inbound_level_three$topic.inbound_level_two.post_from_layer_two.blog_in_topic$post",
-      ];
-      it("three levels inbound", async () => {
-        const { tables, views } = withKeyFromLayerThree();
+      it("three levels inbound", () => {
+        const { tables, views } = withKeyFromLayerThree(__dirname);
         doTest(tables, views, "users", "blog_in_topic_feed", expectedSix);
       });
 
-      it("simple post topic relation", async () => {
+      it("simple post topic relation", () => {
         const expected = [
           ".",
           ".users.favsimpletopic.simple_posts$topic",
@@ -190,20 +155,20 @@ describe("relations tests", () => {
           ".users.messages$user.room.participants$room.user.favsimpletopic.simple_posts$topic",
           ".users.messages$user.room.participants$room.user.favsimpletopic.simple_post_inbound$topic.post",
         ];
-        const { tables, views } = withSimplePostTopicrelation();
+        const { tables, views } = withSimplePostTopicrelation(__dirname);
         doTest(tables, views, "users", "simple_posts_list", expected);
       });
     });
 
     describe("many to many relations", () => {
-      it("artist_plays_on_album", async () => {
-        const { tables, views } = fixturesData();
+      it("artist_plays_on_album", () => {
+        const { tables, views } = fixturesData(__dirname);
         const expected = [".", ".artists.artist_plays_on_album$artist.album"];
         doTest(tables, views, "artists", "albums_feed", expected);
       });
 
-      it("tracks on album", async () => {
-        const { tables, views } = fixturesData();
+      it("tracks on album", () => {
+        const { tables, views } = fixturesData(__dirname);
         const expected = [
           ".",
           ".artists.artist_plays_on_album$artist.album.tracks_on_album$album",
@@ -211,8 +176,8 @@ describe("relations tests", () => {
         doTest(tables, views, "artists", "tracks_on_album_feed", expected);
       });
 
-      it("show pressing_job with embedded fan club feed", async () => {
-        const { tables, views } = fixturesData();
+      it("show pressing_job with embedded fan club feed", () => {
+        const { tables, views } = fixturesData(__dirname);
         const expected = [
           ".",
           ".pressing_job.album.artist_plays_on_album$album.artist.fan_club$artist",
@@ -222,8 +187,8 @@ describe("relations tests", () => {
     });
 
     describe("excluded viewtemplates", () => {
-      it("excluded viewtemplates", async () => {
-        const { tables, views } = fixturesData();
+      it("excluded viewtemplates", () => {
+        const { tables, views } = fixturesData(__dirname);
         const expected = [];
         const excluded = ["Room"];
         doTest(tables, views, "participants", "rooms_view", expected, excluded);
@@ -232,7 +197,7 @@ describe("relations tests", () => {
 
     describe("open legacy relations", () => {
       it("ChildList", async () => {
-        const { tables, views } = fixturesData();
+        const { tables, views } = fixturesData(__dirname);
         const expected = [".", ".books.discusses_books$book"];
         doTest(
           tables,
@@ -247,7 +212,7 @@ describe("relations tests", () => {
       });
 
       it("Independent", async () => {
-        const { tables, views } = fixturesData();
+        const { tables, views } = fixturesData(__dirname);
         const expected = [
           ".",
           ".blog_posts",
@@ -266,7 +231,7 @@ describe("relations tests", () => {
       });
 
       it("Own", async () => {
-        const { tables, views } = fixturesData();
+        const { tables, views } = fixturesData(__dirname);
         const expected = [".books"];
         doTest(
           tables,