relationship updating

Author: paula-stacho

packages/compass-data-modeling/src/components/drawer/field-drawer-content.tsx

@@ -25,10 +25,7 @@ import {
 import { useChangeOnBlur } from './use-change-on-blur';
 import { RelationshipsSection } from './relationships-section';
 import { getFieldFromSchema } from '../../utils/schema-traversal';
-import {
-  areFieldPathsEqual,
-  isRelationshipInvolvingField,
-} from '../../utils/utils';
+import { areFieldPathsEqual, isRelationshipOfAField } from '../../utils/utils';
 
 type FieldDrawerContentProps = {
   namespace: string;
@@ -193,7 +190,7 @@ export default connect(
         })?.fieldTypes ?? [],
       fieldPaths: [], // TODO(COMPASS-9659): get existing field paths
       relationships: model.relationships.filter(({ relationship }) =>
-        isRelationshipInvolvingField(
+        isRelationshipOfAField(
           relationship,
           ownProps.namespace,
           ownProps.fieldPath

packages/compass-data-modeling/src/store/diagram.ts

@@ -14,7 +14,7 @@ import {
   type StaticModel,
 } from '../services/data-model-storage';
 import { AnalysisProcessActionTypes } from './analysis-process';
-import { memoize } from 'lodash';
+import { memoize, update } from 'lodash';
 import type { DataModelingState, DataModelingThunkAction } from './reducer';
 import {
   openToast,
@@ -29,14 +29,12 @@ import type { MongoDBJSONSchema } from 'mongodb-schema';
 import { getCoordinatesForNewNode } from '@mongodb-js/diagramming';
 import { collectionToDiagramNode } from '../utils/nodes-and-edges';
 import toNS from 'mongodb-ns';
-import {
-  removeFieldFromSchema,
-  traverseSchema,
-  updateSchema,
-} from '../utils/schema-traversal';
+import { traverseSchema, updateSchema } from '../utils/schema-traversal';
 import {
   areFieldPathsEqual,
   isRelationshipInvolvingField,
+  isRelationshipOfAField,
+  isSameFieldOrChild,
 } from '../utils/utils';
 
 function isNonEmptyArray<T>(arr: T[]): arr is [T, ...T[]] {
@@ -755,6 +753,27 @@ export function addCollection(
   };
 }
 
+function renameFieldInRelationshipSide(
+  side: Relationship['relationship'][0],
+  edit: Extract<Edit, { type: 'RenameField' }>
+): Relationship['relationship'][0] {
+  if (
+    side.ns !== edit.ns ||
+    !side.fields ||
+    !isSameFieldOrChild(side.fields, edit.from)
+  ) {
+    return side;
+  }
+  return {
+    ...side,
+    fields: [
+      ...side.fields.slice(0, edit.from.length - 1),
+      edit.to,
+      ...side.fields.slice(edit.from.length),
+    ],
+  };
+}
+
 function _applyEdit(edit: Edit, model?: StaticModel): StaticModel {
   if (edit.type === 'SetModel') {
     return edit.model;
@@ -902,8 +921,18 @@ function _applyEdit(edit: Edit, model?: StaticModel): StaticModel {
         ...model,
         // Update any relationships involving the field being renamed.
         relationships: model.relationships.map((r) => {
-          // TODO
-          return r;
+          if (
+            !isRelationshipInvolvingField(r.relationship, edit.ns, edit.from)
+          ) {
+            return r;
+          }
+          return {
+            ...r,
+            relationship: [
+              renameFieldInRelationshipSide(r.relationship[0], edit),
+              renameFieldInRelationshipSide(r.relationship[1], edit),
+            ] as const,
+          };
         }),
         collections: model.collections.map((collection) => {
           if (collection.ns !== edit.ns) return collection;

packages/compass-data-modeling/src/utils/utils.ts

@@ -7,7 +7,21 @@ export function areFieldPathsEqual(
   return JSON.stringify(fieldA) === JSON.stringify(fieldB);
 }
 
-export function isRelationshipInvolvingField(
+export function isSameFieldOrChild(
+  fieldA: FieldPath,
+  fieldB: FieldPath
+): boolean {
+  if (fieldA.length === fieldB.length)
+    return areFieldPathsEqual(fieldA, fieldB);
+  if (fieldA.length < fieldB.length) return false;
+  // fieldA is shorter than fieldB, check if fieldA is a parent of fieldB
+  const pathA = JSON.stringify(fieldA);
+  const pathB = JSON.stringify(fieldB);
+  // ignore the closing bracket - last character in pathB
+  return pathA.slice(0, pathB.length - 1) === pathB.slice(0, pathB.length - 1);
+}
+
+export function isRelationshipOfAField(
   relationship: Relationship['relationship'],
   namespace: string,
   fieldPath: FieldPath
@@ -22,3 +36,19 @@ export function isRelationshipInvolvingField(
       areFieldPathsEqual(foreign.fields, fieldPath))
   );
 }
+
+export function isRelationshipInvolvingField(
+  relationship: Relationship['relationship'],
+  namespace: string,
+  fieldPath: FieldPath
+): boolean {
+  const [local, foreign] = relationship;
+  return (
+    (local.ns === namespace &&
+      local.fields !== null &&
+      isSameFieldOrChild(local.fields, fieldPath)) ||
+    (foreign.ns === namespace &&
+      foreign.fields !== null &&
+      isSameFieldOrChild(foreign.fields, fieldPath))
+  );
+}