@truedat/bg 7.1.3 → 7.1.5

package/src/concepts/selectors/__tests__/getConceptVersionPath.spec.js

@@ -0,0 +1,185 @@
+import { getConceptVersionPath } from "../getConceptVersionPath";
+
+describe("getConceptVersionPath selector (no mocks)", () => {
+  it("returns only the top breadcrumb if no subscope and status is published", () => {
+    // No template matches the concept.type => getConceptSubscope returns null
+    // or we can omit 'type' entirely or mismatch the template name.
+    // Must still have concept.id for getConceptSubscope to even check further.
+    const state = {
+      concept: {
+        id: 1,
+        status: "published",
+      },
+      // No matching template => the sub-scope will be null
+      templates: [{ name: "SomeOtherType", subscope: "someScope" }],
+      sidemenuGlossarySubscopes: undefined,
+    };
+
+    const result = getConceptVersionPath(state);
+    expect(result).toEqual([
+      {
+        id: "concepts.crumbs.top",
+        path: "/concepts",
+      },
+    ]);
+  });
+
+  it("returns only top breadcrumb if getConceptSubscope returns undefined (e.g., concept is missing id)", () => {
+    // Because concept.id is missing, getConceptSubscope returns undefined
+    const state = {
+      concept: {
+        status: "published",
+        // no 'id' property
+      },
+      templates: [{ name: "Foo", subscope: "myScope" }],
+      sidemenuGlossarySubscopes: ["myScope"],
+    };
+
+    const result = getConceptVersionPath(state);
+    expect(result).toEqual([
+      {
+        id: "concepts.crumbs.top",
+        path: "/concepts",
+      },
+    ]);
+  });
+
+  it("includes second breadcrumb (pending) if status is draft and not in side menu, but has subscope", () => {
+    // concept.type matches template => subScope = 'myScope'
+    // 'myScope' is NOT in sidemenuGlossarySubscopes => not root side menu
+    const state = {
+      concept: {
+        id: 2,
+        status: "draft",
+        type: "Foo",
+      },
+      templates: [{ name: "Foo", subscope: "myScope" }],
+      sidemenuGlossarySubscopes: ["otherScope"],
+    };
+
+    const result = getConceptVersionPath(state);
+    expect(result).toEqual([
+      {
+        id: "concepts.crumbs.top",
+        path: "/concepts",
+      },
+      {
+        id: "concepts.crumbs.pending",
+        path: "/concepts/pending",
+      },
+    ]);
+  });
+
+  it("includes second breadcrumb (deprecated) if status is 'deprecated' and not side menu, but has subscope", () => {
+    // match => subScope = 'myScope'
+    const state = {
+      concept: {
+        id: 3,
+        status: "deprecated",
+        type: "Foo",
+      },
+      templates: [{ name: "Foo", subscope: "myScope" }],
+      sidemenuGlossarySubscopes: ["anotherScope"],
+    };
+
+    const result = getConceptVersionPath(state);
+    expect(result).toEqual([
+      {
+        id: "concepts.crumbs.top",
+        path: "/concepts",
+      },
+      {
+        id: "concepts.crumbs.deprecated",
+        path: "/concepts/deprecated",
+      },
+    ]);
+  });
+
+  it("top breadcrumb uses side menu route if subscope is in side menu", () => {
+    // subScope = "someSubscope", which is in sideMenuGlossarySubscopes => root side menu
+    const state = {
+      concept: {
+        id: 4,
+        status: "published",
+        type: "SideMenuScope",
+      },
+      templates: [{ name: "SideMenuScope", subscope: "someSubscope" }],
+      sidemenuGlossarySubscopes: ["someSubscope"],
+    };
+
+    const result = getConceptVersionPath(state);
+
+    // Because it's root side menu, top crumb => /glossarySubscope/someSubscope/published
+    expect(result).toEqual([
+      {
+        id: "concepts.someSubscope.crumbs",
+        path: "/glossarySubscope/someSubscope/published",
+      },
+    ]);
+  });
+
+  it("returns second crumb as pending if status is draft and subscope is in side menu", () => {
+    const state = {
+      concept: {
+        id: 5,
+        status: "draft",
+        type: "SideMenuScope",
+      },
+      templates: [{ name: "SideMenuScope", subscope: "subscopeA" }],
+      sidemenuGlossarySubscopes: ["subscopeA"],
+    };
+
+    const result = getConceptVersionPath(state);
+    expect(result).toEqual([
+      {
+        id: "concepts.subscopeA.crumbs",
+        path: "/glossarySubscope/subscopeA/published",
+      },
+      {
+        id: "concepts.crumbs.pending",
+        path: "/glossarySubscope/subscopeA/pending",
+      },
+    ]);
+  });
+
+  it("returns no second breadcrumb if status is published and subscope is in side menu", () => {
+    const state = {
+      concept: {
+        id: 6,
+        status: "published",
+        type: "SideMenuScope",
+      },
+      templates: [{ name: "SideMenuScope", subscope: "subscopeA" }],
+      sidemenuGlossarySubscopes: ["subscopeA"],
+    };
+
+    const result = getConceptVersionPath(state);
+    expect(result).toEqual([
+      {
+        id: "concepts.subscopeA.crumbs",
+        path: "/glossarySubscope/subscopeA/published",
+      },
+    ]);
+  });
+
+  it("returns only top breadcrumb if subscope is null (concept with null subscope in the matching template)", () => {
+    // subScope found is null => hasSubscope = false => top crumb only
+    const state = {
+      concept: {
+        id: 7,
+        status: "published",
+        type: "NoSubscope",
+      },
+      templates: [{ name: "NoSubscope", subscope: null }],
+      sidemenuGlossarySubscopes: ["subscopeA"],
+    };
+
+    const result = getConceptVersionPath(state);
+    expect(result).toEqual([
+      {
+        id: "concepts.crumbs.top",
+        path: "/concepts",
+      },
+    ]);
+  });
+});

package/src/concepts/selectors/__tests__/getSidemenuGlossarySubscopes.spec.js

@@ -0,0 +1,17 @@
+import { getSidemenuGlossarySubscopes } from "../getSidemenuGlossarySubscopes";
+
+describe("getSidemenuGlossarySubscopes", () => {
+  it("returns the sidemenuGlossarySubscopes array if present", () => {
+    const state = {
+      sidemenuGlossarySubscopes: ["scopeA", "scopeB"],
+    };
+    const result = getSidemenuGlossarySubscopes(state);
+    expect(result).toEqual(["scopeA", "scopeB"]);
+  });
+
+  it("returns an empty array if sidemenuGlossarySubscopes is undefined", () => {
+    const state = {};
+    const result = getSidemenuGlossarySubscopes(state);
+    expect(result).toEqual([]);
+  });
+});

package/src/concepts/selectors/getConceptStatus.js

@@ -0,0 +1 @@
+export const getConceptStatus = (state) => state.concept?.status ?? null;

package/src/concepts/selectors/getConceptSubscope.js

@@ -0,0 +1,19 @@
+import { createSelector } from "reselect";
+import _ from "lodash/fp";
+
+export const getConcept = _.prop("concept");
+export const getTemplates = _.prop("templates");
+
+export const getConceptSubscope = createSelector(
+  [getConcept, getTemplates],
+  (concept, templates) => {
+    if (!concept?.id) {
+      return undefined;
+    }
+
+    const type = _.get("type", concept);
+    const subscopeTemplate = _.find({ name: type }, templates);
+
+    return subscopeTemplate?.subscope || null;
+  }
+);

package/src/concepts/selectors/getConceptVersionPath.js

@@ -0,0 +1,99 @@
+import { createSelector } from "reselect";
+import _ from "lodash/fp";
+import {
+  CONCEPTS,
+  CONCEPTS_DEPRECATED,
+  CONCEPTS_PENDING,
+} from "@truedat/core/routes";
+import { linkTo } from "@truedat/core/routes";
+import { getConceptSubscope } from "./getConceptSubscope";
+import { getSidemenuGlossarySubscopes } from "./getSidemenuGlossarySubscopes";
+
+function isPending(status) {
+  return (
+    status === "draft" || status === "pending_approval" || status === "rejected"
+  );
+}
+
+function buildTopBreadcrumb(isRootSideMenu, subscope) {
+  if (isRootSideMenu) {
+    return {
+      id: `concepts.${subscope}.crumbs`,
+      path: linkTo.CONCEPTS_SIDEMENU_SUBSCOPE({ subscope: subscope }),
+    };
+  }
+  return {
+    id: "concepts.crumbs.top",
+    path: CONCEPTS,
+  };
+}
+
+function buildSecondBreadcrumb({
+  hasSubscope,
+  isRootSideMenu,
+  subscope,
+  status,
+}) {
+  if (!isRootSideMenu) {
+    if (isPending(status)) {
+      return {
+        id: "concepts.crumbs.pending",
+        path: CONCEPTS_PENDING,
+      };
+    }
+    if (status === "deprecated") {
+      return {
+        id: "concepts.crumbs.deprecated",
+        path: CONCEPTS_DEPRECATED,
+      };
+    }
+    if (hasSubscope) {
+      return {
+        id: `concepts.${subscope}.crumbs`,
+        path: linkTo.CONCEPTS_SUBSCOPE({ subscope: subscope }),
+      };
+    }
+    return null;
+  }
+
+  if (isPending(status)) {
+    return {
+      id: `concepts.crumbs.pending`,
+      path: linkTo.CONCEPTS_SIDEMENU_SUBSCOPE_PENDING({ subscope: subscope }),
+    };
+  }
+
+  if (status === "deprecated") {
+    return {
+      id: `concepts.crumbs.deprecated`,
+      path: linkTo.CONCEPTS_SIDEMENU_SUBSCOPE_DEPRECATED({
+        subscope: subscope,
+      }),
+    };
+  }
+
+  return null;
+}
+
+export const getConceptVersionPath = createSelector(
+  [_.prop("concept.status"), getConceptSubscope, getSidemenuGlossarySubscopes],
+  (status, subscope, sideMenuGlossarySubscopes) => {
+    const hasSubscope = subscope !== undefined && subscope !== null;
+
+    const isRootSideMenu =
+      hasSubscope &&
+      Array.isArray(sideMenuGlossarySubscopes) &&
+      sideMenuGlossarySubscopes.includes(subscope);
+
+    const topBreadcrumb = buildTopBreadcrumb(isRootSideMenu, subscope);
+
+    const secondBreadcrumb = buildSecondBreadcrumb({
+      hasSubscope,
+      isRootSideMenu,
+      subscope,
+      status,
+    });
+
+    return [topBreadcrumb, ...(secondBreadcrumb ? [secondBreadcrumb] : [])];
+  }
+);

package/src/concepts/selectors/getSidemenuGlossarySubscopes.js

@@ -0,0 +1,8 @@
+import _ from "lodash/fp";
+
+export const defaultSidemenuGlossarySubscopes = [];
+
+export const getSidemenuGlossarySubscopes = _.getOr(
+  defaultSidemenuGlossarySubscopes,
+  "sidemenuGlossarySubscopes"
+);

package/src/messages/en.js

@@ -118,6 +118,7 @@ export default {
   "concepts.actions.publish": "Publish",
   "concepts.actions.restore": "Restore",
   "concepts.actions.reject": "Reject",
+  "concepts.actions.new": "New",
   "concepts.actions.send_for_approval": "Send for Approval",
   "concepts.actions.undo_rejection": "Rectify",
   "concepts.actions.upload": "Upload file",
@@ -129,6 +130,8 @@ export default {
     "Updated {count} concepts successfully",
   "concepts.bulkUpdate.success.header": "Succeded Bulk Update",
   "concepts.crumbs.top": "Business Glossary",
+  "concepts.crumbs.deprecated": "Deprecated",
+  "concepts.crumbs.pending": "Draft",
   "concepts.edit.bulk.confirmation.content":
     "{concepts_count} concepts will be updated. Are you sure?",
   "concepts.edit.bulk.confirmation.header": "Bulk update",
@@ -180,6 +183,7 @@ export default {
   "concepts.subheader.linksManager": "Query links business concepts",
   "concepts.subheader.manage": "Concept Versions in Progress",
   "concepts.subheader.view": "Query business concepts",
+  "concepts.someSubscope.crumbs": "Some Subscope",
   "concepts.summary": "Summary",
   "concepts.taxonomy": "Taxonomy",
   "concepts.upload.header": "Upload concepts events",

package/src/messages/es.js

@@ -126,6 +126,10 @@ export default {
   "concepts.bulkUpdate.success.content": "Se han actualizado {count} términos",
   "concepts.bulkUpdate.success.header": "Actualización terminada con éxito",
   "concepts.crumbs.top": "Glosario de conceptos",
+  "concepts.crumbs.deprecated": "Archivados",
+  "concepts.actions.new": "Nuevo",
+  "concepts.crumbs.pending": "Borrador",
+  "concepts.someSubscope.crumbs": "Algún Subscope",
   "concepts.edit.bulk.confirmation.content":
     "Se van a actualizar {concepts_count} términos. ¿Estás seguro?",
   "concepts.edit.bulk.confirmation.header": "Actualización masiva",