move out applyEdit

Author: paula-stacho

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

@@ -29,11 +29,8 @@ 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 { traverseSchema, updateSchema } from '../utils/schema-traversal';
-import {
-  isRelationshipInvolvingField,
-  isSameFieldOrAncestor,
-} from '../utils/utils';
+import { traverseSchema } from '../utils/schema-traversal';
+import { applyEdit as _applyEdit } from './apply-edit';
 
 function isNonEmptyArray<T>(arr: T[]): arr is [T, ...T[]] {
   return Array.isArray(arr) && arr.length > 0;
@@ -761,207 +758,6 @@ export function addCollection(
   };
 }
 
-function renameFieldInRelationshipSide(
-  side: Relationship['relationship'][0],
-  edit: Extract<Edit, { type: 'RenameField' }>
-): Relationship['relationship'][0] {
-  if (
-    side.ns !== edit.ns ||
-    !side.fields ||
-    !isSameFieldOrAncestor(edit.field, side.fields)
-  ) {
-    return side;
-  }
-  return {
-    ...side,
-    fields: [
-      ...side.fields.slice(0, edit.field.length - 1),
-      edit.newName,
-      ...side.fields.slice(edit.field.length),
-    ],
-  };
-}
-
-function _applyEdit(edit: Edit, model?: StaticModel): StaticModel {
-  if (edit.type === 'SetModel') {
-    return edit.model;
-  }
-  if (!model) {
-    throw new Error('Editing a model that has not been initialized');
-  }
-  switch (edit.type) {
-    case 'AddCollection': {
-      const newCollection: DataModelCollection = {
-        ns: edit.ns,
-        jsonSchema: edit.initialSchema,
-        displayPosition: edit.position,
-        indexes: [],
-      };
-      return {
-        ...model,
-        collections: [...model.collections, newCollection],
-      };
-    }
-    case 'AddRelationship': {
-      return {
-        ...model,
-        relationships: [...model.relationships, edit.relationship],
-      };
-    }
-    case 'RemoveRelationship': {
-      return {
-        ...model,
-        relationships: model.relationships.filter(
-          (relationship) => relationship.id !== edit.relationshipId
-        ),
-      };
-    }
-    case 'UpdateRelationship': {
-      const existingRelationship = model.relationships.find((r) => {
-        return r.id === edit.relationship.id;
-      });
-      if (!existingRelationship) {
-        throw new Error('Can not update non-existent relationship');
-      }
-      return {
-        ...model,
-        relationships: model.relationships.map((r) => {
-          return r === existingRelationship ? edit.relationship : r;
-        }),
-      };
-    }
-    case 'MoveCollection': {
-      return {
-        ...model,
-        collections: model.collections.map((collection) => {
-          if (collection.ns === edit.ns) {
-            return {
-              ...collection,
-              displayPosition: edit.newPosition,
-            };
-          }
-          return collection;
-        }),
-      };
-    }
-    case 'RemoveCollection': {
-      return {
-        ...model,
-        // Remove any relationships involving the collection being removed.
-        relationships: model.relationships.filter((r) => {
-          return !(
-            r.relationship[0].ns === edit.ns || r.relationship[1].ns === edit.ns
-          );
-        }),
-        collections: model.collections.filter(
-          (collection) => collection.ns !== edit.ns
-        ),
-      };
-    }
-    case 'RenameCollection': {
-      return {
-        ...model,
-        // Update relationships to point to the renamed namespace.
-        relationships: model.relationships.map((relationship) => {
-          const [local, foreign] = relationship.relationship;
-
-          return {
-            ...relationship,
-            relationship: [
-              {
-                ...local,
-                ns: local.ns === edit.fromNS ? edit.toNS : local.ns,
-              },
-              {
-                ...foreign,
-                ns: foreign.ns === edit.fromNS ? edit.toNS : foreign.ns,
-              },
-            ],
-          };
-        }),
-        collections: model.collections.map((collection) => ({
-          ...collection,
-          // Rename the collection.
-          ns: collection.ns === edit.fromNS ? edit.toNS : collection.ns,
-        })),
-      };
-    }
-    case 'UpdateCollectionNote': {
-      return {
-        ...model,
-        collections: model.collections.map((collection) => {
-          if (collection.ns === edit.ns) {
-            return {
-              ...collection,
-              note: edit.note,
-            };
-          }
-          return collection;
-        }),
-      };
-    }
-    case 'RemoveField': {
-      return {
-        ...model,
-        // Remove any relationships involving the field being removed.
-        relationships: model.relationships.filter(({ relationship }) => {
-          return !isRelationshipInvolvingField(
-            relationship,
-            edit.ns,
-            edit.field
-          );
-        }),
-        collections: model.collections.map((collection) => {
-          if (collection.ns !== edit.ns) return collection;
-          return {
-            ...collection,
-            jsonSchema: updateSchema({
-              jsonSchema: collection.jsonSchema,
-              fieldPath: edit.field,
-              update: 'removeField',
-            }),
-          };
-        }),
-      };
-    }
-    case 'RenameField': {
-      return {
-        ...model,
-        // Update any relationships involving the field being renamed.
-        relationships: model.relationships.map((r) => {
-          if (
-            !isRelationshipInvolvingField(r.relationship, edit.ns, edit.field)
-          ) {
-            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;
-          return {
-            ...collection,
-            jsonSchema: updateSchema({
-              jsonSchema: collection.jsonSchema,
-              fieldPath: edit.field,
-              update: 'renameField',
-              newFieldName: edit.newName,
-            }),
-          };
-        }),
-      };
-    }
-    default: {
-      return model;
-    }
-  }
-}
-
 /**
  * @internal Exported for testing purposes only, use `selectCurrentModel` or
  * `selectCurrentModelFromState` instead