@scalar/json-magic 0.1.0

package/src/diff/apply.test.ts

@@ -0,0 +1,262 @@
+import { apply, InvalidChangesDetectedError } from '@/diff/apply'
+import { describe, expect, test } from 'vitest'
+
+const deepClone = <T extends object>(obj: T) => JSON.parse(JSON.stringify(obj)) as T
+
+describe('apply', () => {
+  describe('should apply `add` operations', () => {
+    test('should apply `add` operation correctly', () => {
+      const doc = {
+        name: 'John',
+        age: 25,
+      }
+
+      const docCopy = deepClone(doc)
+      const location = { city: 'New York', street: '5th Avenue' }
+
+      expect(apply(doc, [{ path: ['location'], changes: location, type: 'add' }])).toEqual({
+        ...docCopy,
+        location,
+      })
+    })
+
+    test('should apply `add` operation on deeply nested objects correctly', () => {
+      const doc = {
+        name: 'John',
+        age: 25,
+        location: {
+          city: 'New York',
+          street: '5th Avenue',
+        },
+      }
+
+      const docCopy = deepClone(doc)
+      const coordinates = { lat: 40.7128, long: 74.006 }
+
+      expect(
+        apply(doc, [
+          {
+            path: ['location', 'coordinates'],
+            changes: coordinates,
+            type: 'add',
+          },
+        ]),
+      ).toEqual({
+        ...docCopy,
+        location: {
+          ...docCopy.location,
+          coordinates,
+        },
+      })
+    })
+  })
+
+  describe('should apply `update` operation', () => {
+    test('should apply `update` operation correctly', () => {
+      const doc = {
+        name: 'John',
+        age: 25,
+        location: {
+          city: 'New York',
+          street: '5th Avenue',
+        },
+      }
+      const docCopy = deepClone(doc)
+      const updatedAge = 26
+
+      expect(apply(doc, [{ path: ['age'], changes: updatedAge, type: 'update' }])).toEqual({
+        ...docCopy,
+        age: updatedAge,
+      })
+    })
+
+    test('should apply `update` operation correctly on nested objects', () => {
+      const doc = {
+        name: 'John',
+        age: 25,
+        location: {
+          city: 'New York',
+          street: '5th Avenue',
+        },
+      }
+
+      const docCopy = deepClone(doc)
+      const updatedCity = 'Boston'
+
+      expect(apply(doc, [{ path: ['location', 'city'], changes: updatedCity, type: 'update' }])).toEqual({
+        ...docCopy,
+        location: { ...docCopy.location, city: updatedCity },
+      })
+    })
+  })
+
+  describe('should apply `delete` operation', () => {
+    test('should apply `delete` operation correctly', () => {
+      const doc2 = {
+        name: 'John',
+        age: 25,
+      }
+
+      const doc1 = {
+        ...doc2,
+        location: {
+          city: 'New York',
+          street: '5th Avenue',
+        },
+      }
+
+      expect(apply(doc1, [{ path: ['location'], changes: doc1.location, type: 'delete' }])).toEqual(doc2)
+    })
+
+    test('should apply `delete` operation correctly on nested objects', () => {
+      const doc2 = {
+        name: 'John',
+        age: 25,
+        location: {
+          city: 'New York',
+        },
+      }
+
+      const doc1 = {
+        ...doc2,
+        location: {
+          ...doc2.location,
+          street: '5th Avenue',
+        },
+      }
+
+      expect(
+        apply(doc1, [
+          {
+            path: ['location', 'street'],
+            changes: doc1.location.street,
+            type: 'delete',
+          },
+        ]),
+      ).toEqual(doc2)
+    })
+  })
+
+  describe('should throw on incorrect diff', () => {
+    test('wrong nested key', () => {
+      const doc = {
+        name: 'John',
+        age: 25,
+        location: {
+          city: 'New York',
+          street: '5th Avenue',
+        },
+      }
+
+      expect(() =>
+        apply(doc, [
+          {
+            path: ['location', 'city', 'something'],
+            changes: { test: 1 },
+            type: 'add',
+          },
+        ]),
+      ).toThrow(InvalidChangesDetectedError)
+    })
+
+    test('wrong non existing path', () => {
+      const doc = {
+        name: 'John',
+        age: 25,
+        location: {
+          city: 'New York',
+          street: '5th Avenue',
+        },
+      }
+
+      expect(() =>
+        apply(doc, [
+          {
+            path: ['location', 'coordinates', 'lang'],
+            changes: 41.25,
+            type: 'add',
+          },
+        ]),
+      ).toThrow(InvalidChangesDetectedError)
+    })
+  })
+
+  describe('should correctly handle arrays', () => {
+    test('should correctly apply `add` changes on an array', () => {
+      const doc = {
+        name: 'John',
+        age: 25,
+        location: {
+          city: 'New York',
+          street: '5th Avenue',
+        },
+        hobbies: ['swimming'],
+      }
+
+      const docCopy = deepClone(doc)
+      const newHobby = 'coding'
+
+      expect(
+        apply(doc, [
+          {
+            path: ['hobbies', '1'],
+            changes: newHobby,
+            type: 'add',
+          },
+        ]),
+      ).toEqual({ ...docCopy, hobbies: [...docCopy.hobbies, newHobby] })
+    })
+  })
+
+  test('should correctly apply `update` changes on an array', () => {
+    const doc = {
+      name: 'John',
+      age: 25,
+      location: {
+        city: 'New York',
+        street: '5th Avenue',
+      },
+      hobbies: ['swimming', 'fish', 'coding'],
+    }
+
+    const docCopy = deepClone(doc)
+    const updatedHobby = 'running'
+    docCopy.hobbies[1] = updatedHobby
+
+    expect(
+      apply(doc, [
+        {
+          path: ['hobbies', '1'],
+          changes: updatedHobby,
+          type: 'update',
+        },
+      ]),
+    ).toEqual(docCopy)
+  })
+
+  test('should correctly apply `delete` changes on an array', () => {
+    const doc = {
+      name: 'John',
+      age: 25,
+      location: {
+        city: 'New York',
+        street: '5th Avenue',
+      },
+      hobbies: ['swimming', 'fish', 'coding'],
+    }
+
+    const docCopy = deepClone(doc)
+    // Perform the delete operation
+    docCopy.hobbies.splice(1, 1)
+
+    expect(
+      apply(doc, [
+        {
+          path: ['hobbies', '1'],
+          changes: doc.hobbies[1],
+          type: 'delete',
+        },
+      ]),
+    ).toEqual(docCopy)
+  })
+})

package/src/diff/apply.ts

@@ -0,0 +1,78 @@
+import type { Difference } from '@/diff/diff'
+
+export class InvalidChangesDetectedError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'InvalidChangesDetectedError'
+  }
+}
+
+/**
+ * Applies a set of differences to a document object.
+ * The function traverses the document structure following the paths specified in the differences
+ * and applies the corresponding changes (add, update, or delete) at each location.
+ *
+ * @param document - The original document to apply changes to
+ * @param diff - Array of differences to apply, each containing a path and change type
+ * @returns The modified document with all changes applied
+ *
+ * @example
+ * const original = {
+ *   paths: {
+ *     '/users': {
+ *       get: { responses: { '200': { description: 'OK' } } }
+ *     }
+ *   }
+ * }
+ *
+ * const changes = [
+ *   {
+ *     path: ['paths', '/users', 'get', 'responses', '200', 'content'],
+ *     type: 'add',
+ *     changes: { 'application/json': { schema: { type: 'object' } } }
+ *   }
+ * ]
+ *
+ * const updated = apply(original, changes)
+ * // Result: original document with content added to the 200 response
+ */
+export const apply = (document: Record<string, unknown>, diff: Difference[]): Record<string, unknown> => {
+  // Traverse the object and apply the change
+  const applyChange = (current: any, path: string[], d: Difference, depth = 0) => {
+    if (path[depth] === undefined) {
+      throw new InvalidChangesDetectedError(
+        `Process aborted. Path ${path.join('.')} at depth ${depth} is undefined, check diff object`,
+      )
+    }
+
+    // We reach where we want to be, now we can apply changes
+    if (depth >= path.length - 1) {
+      if (d.type === 'add' || d.type === 'update') {
+        current[path[depth]] = d.changes
+      } else {
+        // For arrays we don't use delete operator since it will leave blank spots and not actually remove the element
+        if (Array.isArray(current)) {
+          current.splice(Number.parseInt(path[depth]), 1)
+        } else {
+          delete current[path[depth]]
+        }
+      }
+      return
+    }
+
+    // Throw an error
+    // This scenario should not happen
+    // 1- if we are adding a new entry, the diff should only give us the higher level diff
+    // 2- if we are updating/deleting an entry, the path to that entry should exists
+    if (current[path[depth]] === undefined || typeof current[path[depth]] !== 'object') {
+      throw new InvalidChangesDetectedError('Process aborted, check diff object')
+    }
+    applyChange(current[path[depth]], path, d, depth + 1)
+  }
+
+  for (const d of diff) {
+    applyChange(document, d.path, d)
+  }
+
+  return document
+}

package/src/diff/diff.test.ts

@@ -0,0 +1,328 @@
+import { diff } from '@/diff'
+import { describe, expect, test } from 'vitest'
+
+describe('diff', () => {
+  describe('Should correctly detect `add` type diff', () => {
+    test('should correctly get added properties between two json objects', () => {
+      const doc1 = {
+        name: 'John',
+        age: 25,
+      }
+
+      const doc2 = {
+        ...doc1,
+        address: {
+          city: 'New York',
+          street: '5th Avenue',
+        },
+      }
+
+      expect(diff(doc1, doc2)).toEqual([{ path: ['address'], changes: doc2.address, type: 'add' }])
+    })
+
+    test('should correctly get added properties in nested objects between two json objects', () => {
+      const doc1 = {
+        name: 'John',
+        age: 25,
+        address: {
+          city: 'New York',
+          street: '5th Avenue',
+        },
+      }
+
+      const doc2 = {
+        ...doc1,
+        address: {
+          ...doc1.address,
+          coordinates: {
+            lat: 40.7128,
+            long: 74.006,
+          },
+        },
+      }
+
+      expect(diff(doc1, doc2)).toEqual([
+        {
+          path: ['address', 'coordinates'],
+          changes: doc2.address.coordinates,
+          type: 'add',
+        },
+      ])
+    })
+
+    test('should correctly get added properties in deeply nested objects between two json objects', () => {
+      const doc1 = {
+        name: 'John',
+        age: 25,
+        address: {
+          city: 'New York',
+          street: '5th Avenue',
+          coordinates: {
+            lat: 40.7128,
+          },
+        },
+      }
+
+      const doc2 = {
+        ...doc1,
+        address: {
+          ...doc1.address,
+          coordinates: {
+            ...doc1.address.coordinates,
+            long: 74.006,
+          },
+        },
+      }
+
+      expect(diff(doc1, doc2)).toEqual([
+        {
+          path: ['address', 'coordinates', 'long'],
+          changes: doc2.address.coordinates.long,
+          type: 'add',
+        },
+      ])
+    })
+  })
+
+  describe('Should correctly detect `update` type diff', () => {
+    test('should correctly get updates on primitives between two objects', () => {
+      const doc1 = {
+        name: 'John',
+        age: 25,
+        address: {
+          city: 'New York',
+          street: '5th Avenue',
+        },
+      }
+
+      const doc2: typeof doc1 = {
+        ...doc1,
+        age: 26,
+      }
+
+      expect(diff(doc1, doc2)).toEqual([{ path: ['age'], changes: doc2.age, type: 'update' }])
+    })
+
+    test('should correctly get updates on nested objects between two objects', () => {
+      const doc1 = {
+        name: 'John',
+        age: 25,
+        address: {
+          city: 'New York',
+          street: '5th Avenue',
+        },
+      }
+
+      const doc2: typeof doc1 = {
+        ...doc1,
+        address: {
+          ...doc1.address,
+          city: 'Los Angeles',
+        },
+      }
+
+      expect(diff(doc1, doc2)).toEqual([
+        {
+          path: ['address', 'city'],
+          changes: doc2.address.city,
+          type: 'update',
+        },
+      ])
+    })
+
+    test('should correctly get updates when the type is different', () => {
+      const doc1 = {
+        name: 'John',
+        age: 25,
+        address: {
+          city: 'New York',
+          street: '5th Avenue',
+        },
+        isStudent: 1,
+      }
+
+      const doc2 = {
+        ...doc1,
+        isStudent: true,
+      }
+
+      expect(diff(doc1, doc2)).toEqual([{ path: ['isStudent'], changes: doc2.isStudent, type: 'update' }])
+    })
+  })
+
+  describe('Should correctly detect `delete` type diff', () => {
+    test('should correctly get removed properties between two objects', () => {
+      const doc2 = {
+        name: 'John',
+        age: 25,
+      }
+
+      const doc1 = {
+        ...doc2,
+        address: {
+          city: 'New York',
+          street: '5th Avenue',
+        },
+      }
+
+      expect(diff(doc1, doc2)).toEqual([{ path: ['address'], changes: doc1.address, type: 'delete' }])
+    })
+
+    test('should correctly get removed properties on deeply nested objects', () => {
+      const doc2 = {
+        name: 'John',
+        age: 25,
+        address: {
+          city: 'New York',
+          street: '5th Avenue',
+        },
+      }
+
+      const doc1 = {
+        ...doc2,
+        address: {
+          ...doc2.address,
+          coordinates: {
+            lat: 40.7128,
+            long: 74.006,
+          },
+        },
+      }
+
+      expect(diff(doc1, doc2)).toEqual([
+        {
+          path: ['address', 'coordinates'],
+          changes: doc1.address.coordinates,
+          type: 'delete',
+        },
+      ])
+    })
+  })
+
+  describe('Should correctly detect changes on arrays', () => {
+    test('detect adding elements on arrays of primitives', () => {
+      const doc1 = {
+        name: 'John',
+        age: 25,
+        hobbies: ['reading', 'running'],
+      }
+
+      const doc2 = {
+        ...doc1,
+        hobbies: ['reading', 'running', 'swimming'],
+      }
+
+      expect(diff(doc1, doc2)).toEqual([{ path: ['hobbies', '2'], changes: doc2.hobbies[2], type: 'add' }])
+    })
+
+    test('detect adding elements on arrays of objects', () => {
+      const doc1 = {
+        name: 'John',
+        age: 25,
+        hobbies: [
+          { name: 'reading', duration: 2 },
+          { name: 'running', duration: 1 },
+        ],
+      }
+
+      const doc2 = {
+        ...doc1,
+        hobbies: [...doc1.hobbies, { name: 'swimming', duration: 3 }],
+      }
+
+      expect(diff(doc1, doc2)).toEqual([{ path: ['hobbies', '2'], changes: doc2.hobbies[2], type: 'add' }])
+    })
+
+    test('detects updates on objects on array of objects', () => {
+      const doc1 = {
+        name: 'John',
+        age: 25,
+        hobbies: [
+          { name: 'reading', duration: 2 },
+          { name: 'running', duration: 1 },
+        ],
+      }
+
+      const doc2 = {
+        ...doc1,
+        hobbies: [doc1.hobbies[0], { name: 'swimming', duration: 3 }],
+      }
+
+      expect(diff(doc1, doc2)).toEqual([
+        {
+          path: ['hobbies', '1', 'name'],
+          changes: doc2.hobbies[1]?.name,
+          type: 'update',
+        },
+        {
+          path: ['hobbies', '1', 'duration'],
+          changes: doc2.hobbies[1]?.duration,
+          type: 'update',
+        },
+      ])
+    })
+
+    test('detects delete operations on array of objects', () => {
+      const doc1 = {
+        name: 'John',
+        age: 25,
+        hobbies: [
+          { name: 'reading', duration: 2 },
+          { name: 'running', duration: 1 },
+        ],
+      }
+
+      const doc2 = {
+        ...doc1,
+        hobbies: [doc1.hobbies[0]],
+      }
+
+      expect(diff(doc1, doc2)).toEqual([{ path: ['hobbies', '1'], changes: doc1.hobbies[1], type: 'delete' }])
+    })
+  })
+
+  test('Should correctly detect multiple changes', () => {
+    const doc1 = {
+      name: 'John',
+      age: 25,
+      address: {
+        city: 'New York',
+        street: '5th Avenue',
+      },
+      hobbies: [
+        { name: 'reading', duration: 2 },
+        { name: 'running', duration: 1 },
+      ],
+      isStudent: true,
+    }
+
+    const doc2 = {
+      ...(doc1 as Partial<typeof doc1>), // Partial is needed to remove the key student key from doc2
+      age: 26,
+      address: {
+        ...doc1.address,
+        city: 'Los Angeles',
+      },
+      hobbies: [doc1.hobbies[0], { name: 'swimming', duration: 3 }, { name: 'running', duration: 2 }],
+    }
+
+    delete doc2.isStudent
+
+    expect(diff(doc1, doc2)).toEqual([
+      { path: ['age'], changes: doc2.age, type: 'update' },
+      { path: ['address', 'city'], changes: doc2.address.city, type: 'update' },
+      {
+        path: ['hobbies', '1', 'name'],
+        changes: doc2.hobbies[1]?.name,
+        type: 'update',
+      },
+      {
+        path: ['hobbies', '1', 'duration'],
+        changes: doc2.hobbies[1]?.duration,
+        type: 'update',
+      },
+      { path: ['hobbies', '2'], changes: doc2.hobbies[2], type: 'add' },
+      { path: ['isStudent'], changes: doc1.isStudent, type: 'delete' },
+    ])
+  })
+})