@scalar/json-magic 0.8.1 → 0.8.3

package/src/diff/apply.test.ts

@@ -1,262 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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 = <T extends Record<string, unknown>>(
-  document: Record<string, unknown>,
-  diff: Difference<T>[],
-): T => {
-  // Traverse the object and apply the change
-  const applyChange = (current: any, path: string[], d: Difference<T>, 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)
-  }
-
-  // It is safe to cast here because this function mutates the input document
-  // to match the target type T as described by the diff changeset.
-  return document as T
-}

package/src/diff/diff.test.ts

@@ -1,328 +0,0 @@
-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' },
-    ])
-  })
-})