@scalar/json-magic 0.1.0 → 0.3.0

package/src/bundle/bundle.test.ts

@@ -10,6 +10,7 @@ import {
   prefixInternalRef,
   prefixInternalRefRecursive,
   setValueAtPath,
+  type LoaderPlugin,
 } from './bundle'
 import { fetchUrls } from './plugins/fetch-urls'
 import { readFiles } from './plugins/read-files'
@@ -18,11 +19,13 @@ import { parseJson } from '@/bundle/plugins/parse-json'
 import { parseYaml } from '@/bundle/plugins/parse-yaml'
 import YAML from 'yaml'
 import { getHash } from '@/bundle/value-generator'
+import { consoleWarnSpy, resetConsoleSpies } from '@scalar/helpers/testing/console-spies'
 
 describe('bundle', () => {
   describe('external urls', () => {
     let server: FastifyInstance
-    const PORT = 7289
+    const port = 7289
+    const url = `http://localhost:${port}`
 
     beforeEach(() => {
       server = fastify({ logger: false })
@@ -34,7 +37,7 @@ describe('bundle', () => {
     })
 
     it('bundles external urls', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       const external = {
         prop: 'I am external json prop',
@@ -43,7 +46,7 @@ describe('bundle', () => {
         reply.send(external)
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: {
@@ -52,7 +55,7 @@ describe('bundle', () => {
           },
         },
         d: {
-          '$ref': `http://localhost:${PORT}#/prop`,
+          '$ref': `http://localhost:${port}#/prop`,
         },
       }
 
@@ -79,7 +82,7 @@ describe('bundle', () => {
     })
 
     it('bundles external urls from resolved external piece', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
       const chunk2 = {
         hey: 'hey',
         nested: {
@@ -104,7 +107,7 @@ describe('bundle', () => {
         reply.send(chunk2)
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: {
@@ -142,7 +145,7 @@ describe('bundle', () => {
     })
 
     it('should correctly handle only urls without a pointer', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       server.get('/', (_, reply) => {
         reply.send({
@@ -150,7 +153,7 @@ describe('bundle', () => {
         })
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: {
@@ -178,7 +181,7 @@ describe('bundle', () => {
 
     it('caches results for same resource', async () => {
       const fn = vi.fn()
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       server.get('/', (_, reply) => {
         fn()
@@ -188,7 +191,7 @@ describe('bundle', () => {
         })
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: {
@@ -221,7 +224,7 @@ describe('bundle', () => {
     })
 
     it('handles correctly external nested refs', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       server.get('/nested/another-file.json', (_, reply) => {
         reply.send({
@@ -237,7 +240,7 @@ describe('bundle', () => {
         })
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: {
@@ -265,7 +268,7 @@ describe('bundle', () => {
     })
 
     it('does not merge paths when we use absolute urls', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       server.get('/top-level', (_, reply) => {
         reply.send({
@@ -281,7 +284,7 @@ describe('bundle', () => {
         })
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: {
@@ -309,7 +312,7 @@ describe('bundle', () => {
     })
 
     it('bundles from a url input', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       server.get('/top-level', (_, reply) => {
         reply.send({
@@ -333,7 +336,7 @@ describe('bundle', () => {
         })
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const output = await bundle(`${url}/base/openapi.json`, { plugins: [fetchUrls()], treeShake: false })
 
@@ -355,7 +358,7 @@ describe('bundle', () => {
     })
 
     it('generated a map when we turn the urlMap on', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       server.get('/top-level', (_, reply) => {
         reply.send({
@@ -379,7 +382,7 @@ describe('bundle', () => {
         })
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const output = await bundle(`${url}/base/openapi.json`, {
         plugins: [fetchUrls()],
@@ -409,7 +412,7 @@ describe('bundle', () => {
     })
 
     it('prefixes the refs only once', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       const chunk2 = {
         a: 'a',
@@ -433,7 +436,7 @@ describe('bundle', () => {
         reply.send(chunk2)
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: {
@@ -493,7 +496,7 @@ describe('bundle', () => {
     })
 
     it('bundles array references', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       const chunk1 = {
         a: {
@@ -505,7 +508,7 @@ describe('bundle', () => {
         reply.send(chunk1)
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: [
@@ -536,7 +539,7 @@ describe('bundle', () => {
     })
 
     it('bundles subpart of the document', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       const chunk1 = {
         a: {
@@ -551,7 +554,7 @@ describe('bundle', () => {
         reply.send(chunk1)
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: {
@@ -631,7 +634,7 @@ describe('bundle', () => {
     })
 
     it('always emits the url mappings when doing partial bundle', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       const chunk1 = {
         a: {
@@ -643,7 +646,7 @@ describe('bundle', () => {
         reply.send(chunk1)
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: {
@@ -693,7 +696,7 @@ describe('bundle', () => {
     })
 
     it('tree shakes the external documents correctly', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       const chunk1 = {
         a: {
@@ -715,7 +718,7 @@ describe('bundle', () => {
         reply.send(chunk1)
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: {
@@ -748,7 +751,7 @@ describe('bundle', () => {
     })
 
     it('tree shakes correctly when working with nested external refs', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       const chunk2 = {
         a: {
@@ -786,7 +789,7 @@ describe('bundle', () => {
         reply.send(chunk2)
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: {
@@ -832,7 +835,7 @@ describe('bundle', () => {
     })
 
     it('handles circular references when we treeshake', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       const chunk1 = {
         a: {
@@ -853,7 +856,7 @@ describe('bundle', () => {
         reply.send(chunk1)
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: {
@@ -887,7 +890,7 @@ describe('bundle', () => {
     })
 
     it('handles chunks', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       const chunk1 = {
         description: 'Chunk 1',
@@ -907,7 +910,7 @@ describe('bundle', () => {
         reply.send(chunk2)
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: {
@@ -985,7 +988,7 @@ describe('bundle', () => {
     })
 
     it('when bundle partial document we ensure all the dependencies references are resolved', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       const chunk1 = {
         a: {
@@ -996,7 +999,7 @@ describe('bundle', () => {
         reply.send(chunk1)
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: {
@@ -1050,7 +1053,7 @@ describe('bundle', () => {
     })
 
     it('should correctly handle nested chunk urls', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       const chunk1 = {
         chunk1: 'chunk1',
@@ -1092,7 +1095,7 @@ describe('bundle', () => {
         reply.send(external)
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         c: {
@@ -1142,7 +1145,7 @@ describe('bundle', () => {
           $ref: '#/a',
         },
         nonBundle: {
-          $ref: `http://localhost:${PORT}/chunk1#`,
+          $ref: `http://localhost:${port}/chunk1#`,
         },
         'x-ext': {
           [await getHash(`${url}/external/document.json`)]: {
@@ -1178,7 +1181,7 @@ describe('bundle', () => {
     })
 
     it('run success hook', async () => {
-      const url = `http://localhost:${PORT}`
+      const url = `http://localhost:${port}`
 
       const chunk1 = {
         description: 'Chunk 1',
@@ -1188,7 +1191,7 @@ describe('bundle', () => {
         reply.send(chunk1)
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: {
@@ -1225,14 +1228,14 @@ describe('bundle', () => {
       expect(resolveError).not.toHaveBeenCalledOnce()
     })
 
-    it('run success hook', async () => {
-      const url = `http://localhost:${PORT}`
+    it('run error hook', async () => {
+      const url = `http://localhost:${port}`
 
       server.get('/chunk1', (_, reply) => {
         reply.code(404).send()
       })
 
-      await server.listen({ port: PORT })
+      await server.listen({ port: port })
 
       const input = {
         a: {
@@ -1268,6 +1271,66 @@ describe('bundle', () => {
       expect(resolveError).toHaveBeenCalledOnce()
       expect(resolveError).toHaveBeenCalledWith(refA)
     })
+
+    it('uses the provided origin for object inputs', async () => {
+      server.get('/', () => ({
+        message: 'some resolved external reference',
+      }))
+      await server.listen({ port })
+
+      const result = await bundle(
+        {
+          a: {
+            $ref: '/#',
+          },
+        },
+        {
+          treeShake: false,
+          plugins: [fetchUrls()],
+          origin: url,
+        },
+      )
+
+      expect(result).toEqual({
+        'a': {
+          '$ref': '#/x-ext/3664f29',
+        },
+        'x-ext': {
+          '3664f29': {
+            'message': 'some resolved external reference',
+          },
+        },
+      })
+    })
+
+    it('prioritizes configuration origin rather than document input url', async () => {
+      server.get('/', () => ({
+        a: {
+          $ref: '/d#',
+        },
+      }))
+      server.get('/a/b/d', () => ({
+        message: 'some resolved external reference',
+      }))
+      await server.listen({ port: port })
+
+      const result = await bundle(url, {
+        plugins: [fetchUrls()],
+        treeShake: false,
+        origin: `${url}/a/b/c`,
+      })
+
+      expect(result).toEqual({
+        'a': {
+          '$ref': '#/x-ext/fb30100',
+        },
+        'x-ext': {
+          'fb30100': {
+            'message': 'some resolved external reference',
+          },
+        },
+      })
+    })
   })
 
   describe('local files', () => {
@@ -1764,6 +1827,493 @@ describe('bundle', () => {
       })
     })
   })
+
+  describe('hooks', () => {
+    describe('onBeforeNodeProcess', () => {
+      it('should correctly call the `onBeforeNodeProcess` correctly on all the nodes', async () => {
+        const fn = vi.fn()
+
+        const input = {
+          someKey: 'someValue',
+          anotherKey: {
+            innerKey: 'nestedValue',
+          },
+        }
+
+        await bundle(input, {
+          plugins: [],
+          treeShake: false,
+          hooks: {
+            onBeforeNodeProcess(node) {
+              fn(node)
+            },
+          },
+        })
+
+        expect(fn).toHaveBeenCalled()
+        expect(fn).toBeCalledTimes(2)
+
+        expect(fn.mock.calls[0][0]).toEqual(input)
+        expect(fn.mock.calls[1][0]).toEqual(input.anotherKey)
+      })
+
+      it('should run bundle on the mutated object properties', async () => {
+        const fn = vi.fn()
+
+        const input = {
+          a: {
+            b: {
+              c: 'c',
+              d: 'd',
+            },
+            e: 'e',
+          },
+        }
+
+        await bundle(input, {
+          plugins: [],
+          treeShake: false,
+          hooks: {
+            onBeforeNodeProcess(node) {
+              if ('e' in node) {
+                node['processedKey'] = { 'message': 'Processed node' }
+              }
+              fn(node)
+            },
+          },
+        })
+
+        expect(fn).toHaveBeenCalled()
+        expect(fn).toBeCalledTimes(4)
+
+        expect(fn.mock.calls[3][0]).toEqual({ 'message': 'Processed node' })
+      })
+    })
+
+    describe('onAfterNodeProcess', () => {
+      it('should call `onAfterNodeProcess` hook on the nodes', async () => {
+        const fn = vi.fn()
+
+        const input = {
+          a: {
+            b: {
+              c: 'c',
+              d: 'd',
+            },
+            e: 'e',
+          },
+        }
+
+        await bundle(input, {
+          plugins: [],
+          treeShake: false,
+          hooks: {
+            onAfterNodeProcess(node) {
+              if ('e' in node) {
+                node['processedKey'] = { 'message': 'Processed node' }
+              }
+              fn(node)
+            },
+          },
+        })
+
+        expect(fn).toHaveBeenCalled()
+        expect(fn).toHaveBeenCalledTimes(3)
+      })
+    })
+  })
+
+  describe('plugins', () => {
+    it('use load plugins to load the documents', async () => {
+      const validate = vi.fn()
+      const exec = vi.fn()
+
+      const resolver = (): LoaderPlugin => {
+        return {
+          type: 'loader',
+          validate(value) {
+            validate(value)
+            return true
+          },
+          async exec(value) {
+            exec(value)
+            return {
+              ok: true,
+              data: { message: 'Resolved document' },
+            }
+          },
+        }
+      }
+
+      const result = await bundle('hello', { treeShake: false, plugins: [resolver()] })
+
+      expect(validate).toHaveBeenCalledOnce()
+      expect(exec).toHaveBeenCalledOnce()
+
+      expect(validate.mock.calls[0][0]).toBe('hello')
+      expect(exec.mock.calls[0][0]).toBe('hello')
+
+      expect(result).toEqual({ message: 'Resolved document' })
+    })
+
+    it('throws if we can not process the input with any of the provided loaders', async () => {
+      const validate = vi.fn()
+      const exec = vi.fn()
+
+      const resolver = (): LoaderPlugin => {
+        return {
+          type: 'loader',
+          validate(value) {
+            validate(value)
+            return false
+          },
+          async exec(value) {
+            exec(value)
+            return {
+              ok: true,
+              data: { message: 'Resolved document' },
+            }
+          },
+        }
+      }
+
+      await expect(bundle('hello', { treeShake: false, plugins: [resolver()] })).rejects.toThrow()
+
+      expect(validate).toHaveBeenCalledOnce()
+      expect(validate.mock.calls[0][0]).toBe('hello')
+
+      expect(exec).not.toHaveBeenCalled()
+    })
+
+    it('use load plugin to resolve external refs', async () => {
+      const validate = vi.fn()
+      const exec = vi.fn()
+
+      const resolver = (): LoaderPlugin => {
+        return {
+          type: 'loader',
+          validate(value) {
+            validate(value)
+            return true
+          },
+          async exec(value) {
+            exec(value)
+            return {
+              ok: true,
+              data: { message: 'Resolved document' },
+            }
+          },
+        }
+      }
+
+      const result = await bundle({ $ref: 'hello' }, { treeShake: false, plugins: [resolver()] })
+
+      expect(validate).toHaveBeenCalledOnce()
+      expect(exec).toHaveBeenCalledOnce()
+
+      expect(validate.mock.calls[0][0]).toBe('hello')
+      expect(exec.mock.calls[0][0]).toBe('hello')
+
+      expect(result).toEqual({
+        $ref: '#/x-ext/aaf4c61',
+        'x-ext': {
+          'aaf4c61': {
+            message: 'Resolved document',
+          },
+        },
+      })
+    })
+
+    it('emits warning when there is no loader to resolve the external ref', async () => {
+      resetConsoleSpies()
+      const validate = vi.fn()
+      const exec = vi.fn()
+
+      const resolver = (): LoaderPlugin => {
+        return {
+          type: 'loader',
+          validate(value) {
+            validate(value)
+            return false
+          },
+          async exec(value) {
+            exec(value)
+            return {
+              ok: true,
+              data: { message: 'Resolved document' },
+            }
+          },
+        }
+      }
+
+      const result = await bundle({ $ref: 'hello' }, { treeShake: false, plugins: [resolver()] })
+
+      expect(validate).toHaveBeenCalledOnce()
+      expect(validate.mock.calls[0][0]).toBe('hello')
+
+      expect(exec).not.toHaveBeenCalled()
+
+      expect(result).toEqual({ $ref: 'hello' })
+
+      expect(consoleWarnSpy).toHaveBeenCalledTimes(1)
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        'Failed to resolve external reference "hello". The reference may be invalid, inaccessible, or missing a loader for this type of reference.',
+      )
+    })
+
+    it('lets plugins hook into nodes lifecycle #1', async () => {
+      const onBeforeNodeProcessCallback = vi.fn()
+      const onAfterNodeProcessCallback = vi.fn()
+
+      await bundle(
+        {
+          prop: {
+            innerProp: 'string',
+          },
+        },
+        {
+          treeShake: false,
+          plugins: [
+            {
+              type: 'lifecycle',
+              onBeforeNodeProcess: onBeforeNodeProcessCallback,
+              onAfterNodeProcess: onAfterNodeProcessCallback,
+            },
+          ],
+        },
+      )
+
+      expect(onBeforeNodeProcessCallback).toHaveBeenCalledTimes(2)
+      expect(onBeforeNodeProcessCallback.mock.calls[0][0]).toEqual({
+        prop: {
+          innerProp: 'string',
+        },
+      })
+      expect(onBeforeNodeProcessCallback.mock.calls[0][1]).toEqual({
+        path: [],
+        resolutionCache: new Map(),
+        parentNode: null,
+        rootNode: {
+          prop: {
+            innerProp: 'string',
+          },
+        },
+        loaders: [],
+      })
+      expect(onBeforeNodeProcessCallback.mock.calls[1][0]).toEqual({
+        innerProp: 'string',
+      })
+      expect(onBeforeNodeProcessCallback.mock.calls[1][1]).toEqual({
+        path: ['prop'],
+        resolutionCache: new Map(),
+        parentNode: {
+          prop: {
+            innerProp: 'string',
+          },
+        },
+        rootNode: {
+          prop: {
+            innerProp: 'string',
+          },
+        },
+        loaders: [],
+      })
+      expect(onAfterNodeProcessCallback).toHaveBeenCalledTimes(2)
+      expect(onAfterNodeProcessCallback.mock.calls[0][0]).toEqual({
+        innerProp: 'string',
+      })
+      expect(onAfterNodeProcessCallback.mock.calls[0][1]).toEqual({
+        path: ['prop'],
+        resolutionCache: new Map(),
+        parentNode: {
+          prop: {
+            innerProp: 'string',
+          },
+        },
+        rootNode: {
+          prop: {
+            innerProp: 'string',
+          },
+        },
+        loaders: [],
+      })
+      expect(onAfterNodeProcessCallback.mock.calls[1][0]).toEqual({
+        prop: {
+          innerProp: 'string',
+        },
+      })
+      expect(onAfterNodeProcessCallback.mock.calls[1][1]).toEqual({
+        path: [],
+        resolutionCache: new Map(),
+        parentNode: null,
+        rootNode: {
+          prop: {
+            innerProp: 'string',
+          },
+        },
+        loaders: [],
+      })
+    })
+
+    it('lets plugins hook into nodes lifecycle #2', async () => {
+      const validate = vi.fn()
+      const exec = vi.fn()
+      const onResolveStart = vi.fn()
+      const onResolveError = vi.fn()
+      const onResolveSuccess = vi.fn()
+      await bundle(
+        {
+          hello: {
+            $ref: 'some-value',
+          },
+          hi: {
+            $ref: 'resolve',
+          },
+        },
+        {
+          treeShake: false,
+          plugins: [
+            {
+              type: 'loader',
+              validate(value) {
+                validate()
+                if (value === 'resolve') {
+                  return true
+                }
+                return false
+              },
+              async exec(value) {
+                exec()
+                return {
+                  ok: true,
+                  data: {
+                    message: 'Resolved value',
+                    'x-original-value': value,
+                  },
+                }
+              },
+            },
+            {
+              type: 'lifecycle',
+              onResolveStart,
+              onResolveError,
+              onResolveSuccess,
+            },
+          ],
+        },
+      )
+
+      expect(validate).toHaveBeenCalledTimes(2)
+      expect(exec).toHaveBeenCalledOnce()
+
+      expect(onResolveStart).toHaveBeenCalledTimes(2)
+      expect(onResolveStart.mock.calls[0][0]).toEqual({
+        $ref: 'some-value',
+      })
+      expect(onResolveStart.mock.calls[1][0]).toEqual({
+        $ref: '#/x-ext/4e7a208',
+      })
+      expect(onResolveError).toHaveBeenCalledTimes(1)
+      expect(onResolveError.mock.calls[0][0]).toEqual({
+        $ref: 'some-value',
+      })
+      expect(onResolveSuccess).toHaveBeenCalledTimes(1)
+      expect(onResolveSuccess.mock.calls[0][0]).toEqual({
+        $ref: '#/x-ext/4e7a208',
+      })
+    })
+
+    it('correctly provides the parent node in different levels', async () => {
+      const onBeforeNodeProcess = vi.fn()
+      const input = {
+        a: {
+          b: {
+            c: {
+              someNode: 'hello world',
+            },
+          },
+        },
+        d: {
+          $ref: '#/a',
+        },
+        e: {
+          f: {
+            $ref: '#/a/b/c',
+          },
+        },
+      }
+
+      await bundle(input, {
+        plugins: [
+          {
+            type: 'lifecycle',
+            onBeforeNodeProcess,
+          },
+        ],
+        treeShake: false,
+      })
+
+      expect(onBeforeNodeProcess).toHaveBeenCalled()
+
+      // First call should be the root with a null parent
+      expect(onBeforeNodeProcess.mock.calls[0][0]).toEqual(input)
+      expect(onBeforeNodeProcess.mock.calls[0][1].parentNode).toEqual(null)
+
+      expect(onBeforeNodeProcess.mock.calls[1][0]).toEqual(input.a)
+      expect(onBeforeNodeProcess.mock.calls[1][1].parentNode).toEqual(input)
+
+      expect(onBeforeNodeProcess.mock.calls[2][0]).toEqual(input.d)
+      expect(onBeforeNodeProcess.mock.calls[2][1].parentNode).toEqual(input)
+
+      expect(onBeforeNodeProcess.mock.calls[3][0]).toEqual(input.e)
+      expect(onBeforeNodeProcess.mock.calls[3][1].parentNode).toEqual(input)
+
+      expect(onBeforeNodeProcess.mock.calls[4][0]).toEqual(input.a.b)
+      expect(onBeforeNodeProcess.mock.calls[4][1].parentNode).toEqual(input.a)
+
+      expect(onBeforeNodeProcess.mock.calls[5][0]).toEqual(input.e.f)
+      expect(onBeforeNodeProcess.mock.calls[5][1].parentNode).toEqual(input.e)
+
+      expect(onBeforeNodeProcess.mock.calls[6][0]).toEqual(input.a.b.c)
+      expect(onBeforeNodeProcess.mock.calls[6][1].parentNode).toEqual(input.a.b)
+    })
+
+    it('correctly provides the parent node on partial bundle for referenced nodes', async () => {
+      const onBeforeNodeProcess = vi.fn()
+
+      const input = {
+        a: {
+          b: 'some-prop',
+        },
+        b: {
+          c: {
+            $ref: '#/a',
+          },
+        },
+      }
+
+      await bundle(input.b, {
+        treeShake: false,
+        root: input,
+        plugins: [
+          {
+            type: 'lifecycle',
+            onBeforeNodeProcess,
+          },
+        ],
+      })
+
+      expect(onBeforeNodeProcess).toHaveBeenCalled()
+      expect(onBeforeNodeProcess.mock.calls[0][0]).toEqual(input.b)
+      expect(onBeforeNodeProcess.mock.calls[0][1].parentNode).toEqual(null)
+
+      expect(onBeforeNodeProcess.mock.calls[1][0]).toEqual(input.b.c)
+      expect(onBeforeNodeProcess.mock.calls[1][1].parentNode).toEqual(input.b)
+
+      expect(onBeforeNodeProcess.mock.calls[2][0]).toEqual(input.a)
+      expect(onBeforeNodeProcess.mock.calls[2][1].parentNode).toEqual(input)
+    })
+  })
 })
 
 describe('isRemoteUrl', () => {