On edit form, display source when a field value is from template (#5900)

Author: bilalabbad

frontend/app/src/app/app.tsx

@@ -4,7 +4,7 @@ import mdiIcons from "@iconify-json/mdi/icons.json";
 import { QueryClientProvider } from "@tanstack/react-query";
 import { Provider } from "jotai";
 import { ErrorBoundary } from "react-error-boundary";
-import { RouterProvider } from "react-router/dom";
+import { RouterProvider } from "react-router";
 import { Slide, ToastContainer } from "react-toastify";
 
 import { TanStackQueryDevtools } from "@/app/devtools";

frontend/app/src/entities/nodes/api/basicMutation.ts

@@ -20,6 +20,7 @@ export const generateObjectEditFormQuery = ({
         edges: {
           node: {
             id: true,
+            hfid: true,
             display_label: true,
             ...addAttributesToRequest(schema.attributes ?? [], {
               withMetadata: true,

frontend/app/src/entities/nodes/object-item-edit/generateObjectEditFormQuery.ts

@@ -0,0 +1,72 @@
+import { RESOURCE_GENERIC_KIND } from "@/entities/resource-manager/constants";
+import { isPoolSchema } from "@/entities/schema/utils/is-pool-schema";
+import { describe, expect, it } from "vitest";
+import { generateGenericSchema, generateNodeSchema } from "../../../../tests/fake/schema";
+
+describe("isPoolSchema", () => {
+  it("should return true for a schema that inherits from resource generic kind", () => {
+    // GIVEN
+    const schema = generateNodeSchema({ inherit_from: [RESOURCE_GENERIC_KIND] });
+
+    // WHEN
+    const result = isPoolSchema(schema);
+
+    // THEN
+    expect(result).toBe(true);
+  });
+
+  it("should return true for a schema that inherits from multiple kinds including resource generic kind", () => {
+    // GIVEN
+    const schema = generateNodeSchema({ inherit_from: ["SomeOtherKind", RESOURCE_GENERIC_KIND] });
+
+    // WHEN
+    const result = isPoolSchema(schema);
+
+    // THEN
+    expect(result).toBe(true);
+  });
+
+  it("should return false for a schema that does not inherit from resource generic kind", () => {
+    // GIVEN
+    const schema = generateNodeSchema({ inherit_from: ["SomeOtherKind"] });
+
+    // WHEN
+    const result = isPoolSchema(schema);
+
+    // THEN
+    expect(result).toBe(false);
+  });
+
+  it("should return false for a schema with undefined inherit_from", () => {
+    // GIVEN
+    const schema = generateNodeSchema({ inherit_from: undefined });
+
+    // WHEN
+    const result = isPoolSchema(schema);
+
+    // THEN
+    expect(result).toBe(false);
+  });
+
+  it("should return false for a schema with empty inherit_from array", () => {
+    // GIVEN
+    const schema = generateNodeSchema({ inherit_from: [] });
+
+    // WHEN
+    const result = isPoolSchema(schema);
+
+    // THEN
+    expect(result).toBe(false);
+  });
+
+  it("should return false for a generic schema even if it inherits from resource generic kind", () => {
+    // GIVEN
+    const schema = generateGenericSchema();
+
+    // WHEN
+    const result = isPoolSchema(schema);
+
+    // THEN
+    expect(result).toBe(false);
+  });
+});

frontend/app/src/entities/schema/utils/is-pool-schema.test.ts

@@ -0,0 +1,7 @@
+import { RESOURCE_GENERIC_KIND } from "@/entities/resource-manager/constants";
+import { ModelSchema } from "@/entities/schema/types";
+import { isGenericSchema } from "@/entities/schema/utils/is-generic-schema";
+
+export function isPoolSchema(schema: ModelSchema): boolean {
+  return !isGenericSchema(schema) && !!schema.inherit_from?.includes(RESOURCE_GENERIC_KIND);
+}

frontend/app/src/entities/schema/utils/is-pool-schema.ts

@@ -65,11 +65,13 @@ describe("addAttributesToRequest", () => {
         is_visible: true,
         source: {
           id: true,
+          hfid: true,
           display_label: true,
           __typename: true,
         },
         owner: {
           id: true,
+          hfid: true,
           display_label: true,
           __typename: true,
         },
@@ -122,11 +124,13 @@ describe("addAttributesToRequest", () => {
         is_visible: true,
         source: {
           id: true,
+          hfid: true,
           display_label: true,
           __typename: true,
         },
         owner: {
           id: true,
+          hfid: true,
           display_label: true,
           __typename: true,
         },
@@ -206,11 +210,13 @@ describe("addRelationshipsToRequest", () => {
           updated_at: true,
           source: {
             id: true,
+            hfid: true,
             display_label: true,
             __typename: true,
           },
           owner: {
             id: true,
+            hfid: true,
             display_label: true,
             __typename: true,
           },

frontend/app/src/shared/api/graphql/utils.test.ts

@@ -35,11 +35,13 @@ export const addAttributesToRequest = (
         is_visible: true,
         source: {
           id: true,
+          hfid: true,
           display_label: true,
           __typename: true,
         },
         owner: {
           id: true,
+          hfid: true,
           display_label: true,
           __typename: true,
         },
@@ -79,11 +81,13 @@ export const addRelationshipsToRequest = (
         updated_at: true,
         source: {
           id: true,
+          hfid: true,
           display_label: true,
           __typename: true,
         },
         owner: {
           id: true,
+          hfid: true,
           display_label: true,
           __typename: true,
         },

frontend/app/src/shared/api/graphql/utils.ts

@@ -1,14 +1,43 @@
 import { AttributeType } from "@/entities/nodes/getObjectItemDisplayValue";
 import { NodeObject } from "@/entities/nodes/types";
+import {
+  genericSchemasAtom,
+  nodeSchemasAtom,
+  profileSchemasAtom,
+  templateSchemasAtom,
+} from "@/entities/schema/stores/schema.atom";
 import { ProfileData } from "@/shared/components/form/object-form";
 import {
   GetFieldDefaultValue,
   getFieldDefaultValue,
 } from "@/shared/components/form/utils/getFieldDefaultValue";
-import { describe, expect, it } from "vitest";
+import { store } from "@/shared/stores";
+import { beforeEach, describe, expect, it } from "vitest";
+import {
+  generateGenericSchema,
+  generateNodeSchema,
+  generateProfileSchema,
+  generateTemplateSchema,
+} from "../../../../../tests/fake/schema";
 import { buildAttributeSchema, buildRelationshipSchema } from "./getFormFieldsFromSchema.test";
 
 describe("getFieldDefaultValue", () => {
+  beforeEach(() => {
+    // Initialize schema store with necessary schemas for type checking
+    const nodeSchema = generateNodeSchema({ kind: "Node" });
+    const genericSchema = generateGenericSchema({ kind: "Generic" });
+    const profileSchema = generateProfileSchema({ kind: "Profile" });
+    const templateSchema = generateTemplateSchema({ kind: "Template" });
+    const fakeProfileSchema = generateProfileSchema({ kind: "FakeProfileKind" });
+    const poolSchema = generateGenericSchema({ kind: "FakePool" });
+    const fakeTemplateSchema = generateTemplateSchema({ kind: "FakeTemplateKind" });
+
+    store.set(nodeSchemasAtom, [nodeSchema]);
+    store.set(genericSchemasAtom, [genericSchema, poolSchema]);
+    store.set(profileSchemasAtom, [profileSchema, fakeProfileSchema]);
+    store.set(templateSchemasAtom, [templateSchema, fakeTemplateSchema]);
+  });
+
   describe("when source is the user", () => {
     it("returns current object field's value when value is not from profile", () => {
       // GIVEN
@@ -524,6 +553,36 @@ describe("getFieldDefaultValue", () => {
         value: null,
       });
     });
+
+    it("retuns template when source is template", () => {
+      // GIVEN
+      const fieldSchema = buildAttributeSchema({ default_value: "my-default-value" });
+
+      const initialObject: Record<string, AttributeType> = {
+        field1: {
+          value: "my-value",
+          source: {
+            id: "template-id",
+            display_label: "Template",
+            __typename: "FakeTemplateKind",
+          },
+        },
+      };
+
+      // WHEN
+      const defaultValue = getFieldDefaultValue({ fieldSchema, initialObject });
+
+      // THEN
+      expect(defaultValue).to.deep.equal({
+        source: {
+          id: "template-id",
+          kind: "FakeTemplateKind",
+          label: "Template",
+          type: "template",
+        },
+        value: "my-value",
+      });
+    });
   });
 
   describe("when source is pool", () => {

frontend/app/src/shared/components/form/utils/getFieldDefaultValue.test.ts

@@ -1,6 +1,9 @@
 import { AttributeType, FieldSchema } from "@/entities/nodes/getObjectItemDisplayValue";
 import { getNodeLabel } from "@/entities/nodes/object/utils/get-node-label";
-import { NodeAttribute, NodeObject } from "@/entities/nodes/types";
+import { NodeAttribute, NodeCore, NodeObject } from "@/entities/nodes/types";
+import { getSchema } from "@/entities/schema/domain/get-schema";
+import { isPoolSchema } from "@/entities/schema/utils/is-pool-schema";
+import { isTemplateSchema } from "@/entities/schema/utils/is-template-schema";
 import { LineageSource } from "@/shared/api/graphql/generated/graphql";
 import { ProfileData } from "@/shared/components/form/object-form";
 import {
@@ -44,7 +47,7 @@ export const getFieldDefaultValue = ({
 export const getCurrentFieldValue = (
   fieldName: string,
   objectData?: Record<string, AttributeType>
-): AttributeValueFromUser | null => {
+): AttributeValueFromUser | AttributeValueFromTemplate | null => {
   if (!objectData) return null;
 
   const currentField = objectData[fieldName];
@@ -55,11 +58,42 @@ export const getCurrentFieldValue = (
     return null;
   }
 
-  if (currentField.source?.__typename?.match(/Pool$/g)) {
-    return null;
+  if (currentField.source && "__typename" in currentField.source) {
+    const sourceKind = currentField.source.__typename as string;
+    const { schema: sourceSchema } = getSchema(sourceKind);
+
+    if (!sourceSchema) {
+      return {
+        source: { type: "user" },
+        value: currentField.value,
+      };
+    }
+
+    if (isPoolSchema(sourceSchema)) {
+      return null;
+    }
+
+    if (isTemplateSchema(sourceSchema)) {
+      return {
+        source: {
+          type: "template",
+          label: getNodeLabel(currentField.source as NodeCore),
+          kind: sourceKind,
+          id: currentField.source.id as string,
+        },
+        value: currentField.value,
+      };
+    }
+
+    if (sourceKind.includes("Pool")) {
+      return null;
+    }
   }
 
-  return { source: { type: "user" }, value: currentField.value };
+  return {
+    source: { type: "user" },
+    value: currentField.value,
+  };
 };
 
 const getDefaultValueFromProfiles = (

frontend/app/src/shared/components/form/utils/getFieldDefaultValue.ts

@@ -6,21 +6,6 @@ export const classNames = (...classes: ClassValue[]) => {
   return twMerge(clsx(classes));
 };
 
-export const objectToString = (object: any) =>
-  Object.entries(object)
-    .map(([key, value]) => {
-      switch (typeof value) {
-        // Add quotes for string
-        case "string": {
-          return `${key}:"${value}"`;
-        }
-        default: {
-          return `${key}:${value}`;
-        }
-      }
-    })
-    .join(",");
-
 export const sortByName = R.sortBy(R.compose(R.toLower, R.prop("name")));
 
 export const sortByOrderWeight = R.sortBy(R.compose(R.prop("order_weight")));