@scalar/json-magic 0.6.0 → 0.7.0

package/src/bundle/bundle.ts

@@ -65,7 +65,7 @@ export function isLocalRef(value: string): boolean {
   return value.startsWith('#')
 }
 
-export type ResolveResult = { ok: true; data: unknown } | { ok: false }
+export type ResolveResult = { ok: true; data: unknown; raw: string } | { ok: false }
 
 /**
  * Resolves a string by finding and executing the appropriate plugin.
@@ -80,16 +80,16 @@ export type ResolveResult = { ok: true; data: unknown } | { ok: false }
  * // No matching plugin returns { ok: false }
  * await resolveContents('#/components/schemas/User', [urlPlugin, filePlugin])
  */
-async function resolveContents(value: string, plugins: LoaderPlugin[]): Promise<ResolveResult> {
+function resolveContents(value: string, plugins: LoaderPlugin[]): Promise<ResolveResult> {
   const plugin = plugins.find((p) => p.validate(value))
 
   if (plugin) {
     return plugin.exec(value)
   }
 
-  return {
+  return Promise.resolve({
     ok: false,
-  }
+  })
 }
 
 /**

package/src/bundle/plugins/fetch-urls/index.test.ts

@@ -1,9 +1,10 @@
-import { fastify, type FastifyInstance } from 'fastify'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { fetchUrl } from '.'
-import assert from 'node:assert'
 import { setTimeout } from 'node:timers/promises'
 
+import { type FastifyInstance, fastify } from 'fastify'
+import { assert, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { fetchUrl } from '.'
+
 describe('fetchUrl', () => {
   const noLimit = <T>(fn: () => Promise<T>) => fn()
 
@@ -12,11 +13,11 @@ describe('fetchUrl', () => {
 
   beforeEach(() => {
     server = fastify({ logger: false })
-  })
 
-  afterEach(async () => {
-    await server.close()
-    await setTimeout(100)
+    return async () => {
+      await server.close()
+      await setTimeout(100)
+    }
   })
 
   it('reads json response', async () => {
@@ -71,14 +72,14 @@ describe('fetchUrl', () => {
 
   it('send headers to the specified domain', async () => {
     const url = `http://localhost:${PORT}`
-    const fn = vi.fn()
+    const headersSpy = vi.fn()
 
     const response = {
       message: '200OK',
     }
 
     server.get('/', (request, reply) => {
-      fn(request.headers)
+      headersSpy(request.headers)
       reply.send(response)
     })
 
@@ -87,8 +88,8 @@ describe('fetchUrl', () => {
       headers: [{ headers: { 'Authorization': 'Bearer <TOKEN>' }, domains: [`localhost:${PORT}`] }],
     })
 
-    expect(fn).toHaveBeenCalled()
-    expect(fn.mock.calls[0][0]).toEqual({
+    expect(headersSpy).toHaveBeenCalledOnce()
+    expect(headersSpy).toHaveBeenCalledWith({
       'accept': '*/*',
       'accept-encoding': 'gzip, deflate',
       'accept-language': '*',
@@ -102,14 +103,14 @@ describe('fetchUrl', () => {
 
   it('does not send headers to other domains', async () => {
     const url = `http://localhost:${PORT}`
-    const fn = vi.fn()
+    const headersSpy = vi.fn()
 
     const response = {
       message: '200OK',
     }
 
     server.get('/', (request, reply) => {
-      fn(request.headers)
+      headersSpy(request.headers)
       reply.send(response)
     })
 
@@ -118,8 +119,8 @@ describe('fetchUrl', () => {
       headers: [{ headers: { 'Authorization': 'Bearer <TOKEN>' }, domains: ['localhost:9932', 'localhost'] }],
     })
 
-    expect(fn).toHaveBeenCalled()
-    expect(fn.mock.calls[0][0]).toEqual({
+    expect(headersSpy).toHaveBeenCalledOnce()
+    expect(headersSpy).toHaveBeenNthCalledWith(1, {
       'accept': '*/*',
       'accept-encoding': 'gzip, deflate',
       'accept-language': '*',
@@ -131,17 +132,13 @@ describe('fetchUrl', () => {
   })
 
   it('runs custom fetcher', async () => {
-    const fn = vi.fn()
+    const customFetch = vi.fn().mockResolvedValue(new Response('{}', { status: 200 }))
 
     await fetchUrl('https://example.com', (fn) => fn(), {
-      fetch: async (input, init) => {
-        fn(input, init)
-
-        return new Response('{}', { status: 200 })
-      },
+      fetch: customFetch,
     })
 
-    expect(fn).toHaveBeenCalled()
-    expect(fn).toHaveBeenCalledWith('https://example.com', { headers: undefined })
+    expect(customFetch).toHaveBeenCalledOnce()
+    expect(customFetch).toHaveBeenCalledWith('https://example.com', { headers: undefined })
   })
 })

package/src/bundle/plugins/fetch-urls/index.ts

@@ -59,13 +59,23 @@ export async function fetchUrl(
       return {
         ok: true,
         data: normalize(body),
+        raw: body,
       }
     }
 
+    const contentType = result.headers.get('Content-Type') ?? ''
+
+    // Warn if the content type is HTML or XML as we only support JSON/YAML
+    if (['text/html', 'application/xml'].includes(contentType)) {
+      console.warn(`[WARN] We only support JSON/YAML formats, received ${contentType}`)
+    }
+
+    console.warn(`[WARN] Fetch failed with status ${result.status} ${result.statusText} for URL: ${url}`)
     return {
       ok: false,
     }
   } catch {
+    console.warn(`[WARN] Failed to parse JSON/YAML from URL: ${url}`)
     return {
       ok: false,
     }

package/src/bundle/plugins/parse-json/index.test.ts

@@ -1,6 +1,7 @@
-import { parseJson } from '@/bundle/plugins/parse-json'
 import { describe, expect, it } from 'vitest'
 
+import { parseJson } from '@/bundle/plugins/parse-json'
+
 describe('parse-json', () => {
   it.each([
     ['{}', true],
@@ -17,6 +18,7 @@ describe('parse-json', () => {
     expect(await parseJson().exec('{ "message": "Hello World" }')).toEqual({
       ok: true,
       data: { message: 'Hello World' },
+      'raw': '{ "message": "Hello World" }',
     })
   })
 })

package/src/bundle/plugins/parse-json/index.ts

@@ -1,4 +1,4 @@
-import type { LoaderPlugin, ResolveResult } from '@/bundle'
+import type { LoaderPlugin } from '@/bundle'
 import { isJsonObject } from '@/helpers/is-json-object'
 
 /**
@@ -15,16 +15,17 @@ export function parseJson(): LoaderPlugin {
   return {
     type: 'loader',
     validate: isJsonObject,
-    exec: async (value): Promise<ResolveResult> => {
+    exec: (value) => {
       try {
-        return {
+        return Promise.resolve({
           ok: true,
           data: JSON.parse(value),
-        }
+          raw: value,
+        })
       } catch {
-        return {
+        return Promise.resolve({
           ok: false,
-        }
+        })
       }
     },
   }

package/src/bundle/plugins/parse-yaml/index.test.ts

@@ -1,6 +1,7 @@
-import { parseYaml } from '@/bundle/plugins/parse-yaml'
 import { describe, expect, it } from 'vitest'
 
+import { parseYaml } from '@/bundle/plugins/parse-yaml'
+
 describe('parse-yaml', () => {
   it.each([
     ['hi: hello\n', true],
@@ -19,6 +20,7 @@ describe('parse-yaml', () => {
     expect(await parseYaml().exec('{ "message": "Hello World" }')).toEqual({
       ok: true,
       data: { message: 'Hello World' },
+      'raw': '{ "message": "Hello World" }',
     })
   })
 })

package/src/bundle/plugins/parse-yaml/index.ts

@@ -1,6 +1,6 @@
 import YAML from 'yaml'
 
-import type { LoaderPlugin, ResolveResult } from '@/bundle'
+import type { LoaderPlugin } from '@/bundle'
 import { isYaml } from '@/helpers/is-yaml'
 
 /**
@@ -17,16 +17,17 @@ export function parseYaml(): LoaderPlugin {
   return {
     type: 'loader',
     validate: isYaml,
-    exec: async (value): Promise<ResolveResult> => {
+    exec: (value) => {
       try {
-        return {
+        return Promise.resolve({
           ok: true,
           data: YAML.parse(value, { merge: true, maxAliasCount: 10000 }),
-        }
+          raw: value,
+        })
       } catch {
-        return {
+        return Promise.resolve({
           ok: false,
-        }
+        })
       }
     },
   }

package/src/bundle/plugins/read-files/index.test.ts

@@ -1,8 +1,9 @@
-import fs from 'node:fs/promises'
 import { randomUUID } from 'node:crypto'
-import { describe, expect, it } from 'vitest'
+import fs from 'node:fs/promises'
+
+import { assert, describe, expect, it } from 'vitest'
+
 import { readFile } from '.'
-import assert from 'node:assert'
 
 describe('readFile', () => {
   it('reads json contents of a file', async () => {

package/src/bundle/plugins/read-files/index.ts

@@ -29,6 +29,7 @@ export async function readFile(path: string): Promise<ResolveResult> {
     return {
       ok: true,
       data: normalize(fileContents),
+      raw: fileContents,
     }
   } catch {
     return {

package/src/bundle/value-generator.test.ts

@@ -1,9 +1,10 @@
-import { generateUniqueValue, uniqueValueGeneratorFactory } from './value-generator'
 import { describe, expect, it } from 'vitest'
 
+import { generateUniqueValue, uniqueValueGeneratorFactory } from './value-generator'
+
 describe('generateUniqueHash', () => {
   it('should generate hash values from the function we pass in', async () => {
-    const hashFunction = async (value: string) => {
+    const hashFunction = (value: string) => {
       if (value === 'a') {
         return 'a'
       }
@@ -16,7 +17,7 @@ describe('generateUniqueHash', () => {
   })
 
   it('should return same value for the same input', async () => {
-    const hashFunction = async (value: string) => {
+    const hashFunction = (value: string) => {
       if (value === 'a') {
         return value
       }
@@ -33,7 +34,7 @@ describe('generateUniqueHash', () => {
   })
 
   it('should handle hash collisions', async () => {
-    const hashFunction = async (value: string) => {
+    const hashFunction = (value: string) => {
       // Hash a, b and c will produce collisions
       if (value === 'a' || value === 'b' || value === 'c') {
         return 'd'
@@ -83,9 +84,7 @@ describe('generateUniqueHash', () => {
   })
 
   it('should throw when it reaches max depth', async () => {
-    const hashFunction = async () => {
-      return 'a'
-    }
+    const hashFunction = () => 'a'
 
     const map = {}
     const result1 = await generateUniqueValue(hashFunction, 'a', map)
@@ -94,7 +93,7 @@ describe('generateUniqueHash', () => {
     const result2 = await generateUniqueValue(hashFunction, 'a', map)
     expect(result2).toBe('a')
 
-    expect(() => generateUniqueValue(hashFunction, 'b', map)).rejects.toThrowError()
+    await expect(() => generateUniqueValue(hashFunction, 'b', map)).rejects.toThrowError()
   })
 })
 

package/src/dereference/dereference.test.ts

@@ -1,11 +1,13 @@
-import { dereference } from '@/dereference/dereference'
-import { fastify, type FastifyInstance } from 'fastify'
 import { setTimeout } from 'node:timers/promises'
+
+import { type FastifyInstance, fastify } from 'fastify'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 
+import { dereference } from '@/dereference/dereference'
+
 describe('dereference', () => {
   describe('sync', () => {
-    it('should dereference JSON pointers', async () => {
+    it('should dereference JSON pointers', () => {
       const data = {
         users: {
           name: 'John Doe',
@@ -82,9 +84,7 @@ describe('dereference', () => {
           street: 'Sunset Boulevard',
         },
       }
-      server.get('/users', async () => {
-        return userProfile
-      })
+      server.get('/users', () => userProfile)
 
       await server.listen({ port: port })
 

package/src/diff/diff.ts

@@ -76,7 +76,6 @@ export const diff = <T extends Record<string, unknown>>(doc1: Record<string, unk
       const keys = new Set([...Object.keys(el1), ...Object.keys(el2)])
 
       for (const key of keys) {
-        // @ts-ignore
         bfs(el1[key], el2[key], [...prefix, key])
       }
       return

package/src/diff/utils.test.ts

@@ -148,7 +148,7 @@ describe('isArrayEqual', () => {
       [1, 2, 3],
       [1, 2, 3],
     ],
-    // @ts-ignore
+    // @ts-expect-error
   ])('should return true', (a, b) => expect(isArrayEqual(a, b)).toEqual(true))
 
   test.each([
@@ -164,6 +164,6 @@ describe('isArrayEqual', () => {
       [2, 2, 4],
       [1, 2, 3],
     ],
-    // @ts-ignore
+    // @ts-expect-error
   ])('should return false', (a, b) => expect(isArrayEqual(a, b)).toEqual(false))
 })

package/src/diff/utils.ts

@@ -28,9 +28,7 @@ export const isKeyCollisions = (a: unknown, b: unknown) => {
     const keys = new Set([...Object.keys(a), ...Object.keys(b)])
 
     for (const key of keys) {
-      // @ts-ignore
       if (a[key] !== undefined && b[key] !== undefined) {
-        // @ts-ignore
         if (isKeyCollisions(a[key], b[key])) {
           return true
         }

package/src/helpers/escape-json-pointer.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest'
 
 import { escapeJsonPointer } from './escape-json-pointer'
 
-describe('escapeJsonPointer', async () => {
+describe('escapeJsonPointer', () => {
   it('should escape a slash', () => {
     expect(escapeJsonPointer('application/json')).toBe('application~1json')
   })

package/src/helpers/unescape-json-pointer.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest'
 
 import { unescapeJsonPointer } from './unescape-json-pointer'
 
-describe('unescapeJsonPointer', async () => {
+describe('unescapeJsonPointer', () => {
   it('unescapes a slash', () => {
     expect(unescapeJsonPointer('/foo~1bar~1baz')).toBe('/foo/bar/baz')
   })