@scalar/json-magic 0.8.2 → 0.8.3

package/src/helpers/convert-to-local-ref.test.ts

@@ -1,211 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { convertToLocalRef } from './convert-to-local-ref'
-
-describe('convertToLocalRef', () => {
-  const schemas = new Map([
-    ['https://example.com/schema1.json', '/components/schemas/Schema1'],
-    ['https://example.com/schema2.json', '/components/schemas/Schema2'],
-    ['https://example.com/schema1.json#anchor1', '/components/schemas/Schema1/definitions/Anchor1'],
-    ['https://example.com/schema2.json#anchor2', '/components/schemas/Schema2/definitions/Anchor2'],
-    ['https://example.com/current.json#currentAnchor', '/components/schemas/Current/definitions/CurrentAnchor'],
-  ])
-
-  const currentContext = 'https://example.com/current.json'
-
-  describe('external references with baseUrl', () => {
-    it('should resolve external reference without path or anchor', () => {
-      const result = convertToLocalRef('https://example.com/schema1.json', currentContext, schemas)
-
-      expect(result).toBe('/components/schemas/Schema1')
-    })
-
-    it('should resolve external reference with JSON pointer path', () => {
-      const result = convertToLocalRef('https://example.com/schema1.json#/definitions/User', currentContext, schemas)
-
-      expect(result).toBe('/components/schemas/Schema1/definitions/User')
-    })
-
-    it('should resolve external reference with anchor', () => {
-      const result = convertToLocalRef('https://example.com/schema1.json#anchor1', currentContext, schemas)
-
-      expect(result).toBe('/components/schemas/Schema1/definitions/Anchor1')
-    })
-
-    it('should return undefined for external reference not in schemas', () => {
-      const result = convertToLocalRef('https://example.com/unknown.json', currentContext, schemas)
-
-      expect(result).toBeUndefined()
-    })
-
-    it('should return undefined for external reference with unknown anchor', () => {
-      const result = convertToLocalRef('https://example.com/schema1.json#unknownAnchor', currentContext, schemas)
-
-      expect(result).toBeUndefined()
-    })
-  })
-
-  describe('local references without baseUrl', () => {
-    it('should resolve local JSON pointer path', () => {
-      const result = convertToLocalRef('#/definitions/User', currentContext, schemas)
-
-      expect(result).toBe('definitions/User')
-    })
-
-    it('should resolve local JSON pointer path with multiple segments', () => {
-      const result = convertToLocalRef('#/components/schemas/User/properties/name', currentContext, schemas)
-
-      expect(result).toBe('components/schemas/User/properties/name')
-    })
-
-    it('should resolve local anchor reference', () => {
-      const result = convertToLocalRef('#currentAnchor', currentContext, schemas)
-
-      expect(result).toBe('/components/schemas/Current/definitions/CurrentAnchor')
-    })
-
-    it('should return undefined for local anchor not in schemas', () => {
-      const result = convertToLocalRef('#unknownAnchor', currentContext, schemas)
-
-      expect(result).toBeUndefined()
-    })
-  })
-
-  describe('edge cases', () => {
-    it('should return undefined for empty reference', () => {
-      const result = convertToLocalRef('', currentContext, schemas)
-
-      expect(result).toBeUndefined()
-    })
-
-    it('should return undefined for reference with only hash', () => {
-      const result = convertToLocalRef('#', currentContext, schemas)
-
-      expect(result).toBeUndefined()
-    })
-
-    it('should return undefined for reference with only baseUrl and hash', () => {
-      const result = convertToLocalRef('https://example.com/schema1.json#', currentContext, schemas)
-
-      expect(result).toBe('/components/schemas/Schema1')
-    })
-
-    it('should handle empty currentContext', () => {
-      const result = convertToLocalRef('#anchor', '', schemas)
-
-      expect(result).toBeUndefined()
-    })
-
-    it('should handle empty schemas map', () => {
-      const emptySchemas = new Map()
-      const result = convertToLocalRef('https://example.com/schema1.json', currentContext, emptySchemas)
-
-      expect(result).toBeUndefined()
-    })
-  })
-
-  describe('complex scenarios', () => {
-    it('should handle nested JSON pointer paths', () => {
-      const result = convertToLocalRef(
-        'https://example.com/schema1.json#/definitions/User/properties/address/properties/street',
-        currentContext,
-        schemas,
-      )
-
-      expect(result).toBe('/components/schemas/Schema1/definitions/User/properties/address/properties/street')
-    })
-
-    it('should handle anchor with special characters', () => {
-      const schemasWithSpecialChars = new Map([
-        ['https://example.com/schema1.json', '/components/schemas/Schema1'],
-        [
-          'https://example.com/schema1.json#anchor-with-dashes',
-          '/components/schemas/Schema1/definitions/AnchorWithDashes',
-        ],
-        [
-          'https://example.com/schema1.json#anchor_with_underscores',
-          '/components/schemas/Schema1/definitions/AnchorWithUnderscores',
-        ],
-      ])
-
-      const result1 = convertToLocalRef(
-        'https://example.com/schema1.json#anchor-with-dashes',
-        currentContext,
-        schemasWithSpecialChars,
-      )
-
-      const result2 = convertToLocalRef(
-        'https://example.com/schema1.json#anchor_with_underscores',
-        currentContext,
-        schemasWithSpecialChars,
-      )
-
-      expect(result1).toBe('/components/schemas/Schema1/definitions/AnchorWithDashes')
-      expect(result2).toBe('/components/schemas/Schema1/definitions/AnchorWithUnderscores')
-    })
-
-    it('should handle different schema contexts', () => {
-      const differentContext = 'https://example.com/different.json'
-      const schemasWithDifferentContext = new Map([
-        [
-          'https://example.com/different.json#differentAnchor',
-          '/components/schemas/Different/definitions/DifferentAnchor',
-        ],
-      ])
-
-      const result = convertToLocalRef('#differentAnchor', differentContext, schemasWithDifferentContext)
-
-      expect(result).toBe('/components/schemas/Different/definitions/DifferentAnchor')
-    })
-  })
-
-  describe('real-world examples', () => {
-    it('should handle OpenAPI component references', () => {
-      const openApiSchemas = new Map([
-        ['https://api.example.com/schemas/user.json', '/components/schemas/User'],
-        ['https://api.example.com/schemas/user.json#/properties/id', '/components/schemas/User/properties/id'],
-        ['https://api.example.com/schemas/user.json#userProfile', '/components/schemas/User/definitions/UserProfile'],
-      ])
-
-      const result1 = convertToLocalRef(
-        'https://api.example.com/schemas/user.json',
-        'https://api.example.com/openapi.json',
-        openApiSchemas,
-      )
-
-      const result2 = convertToLocalRef(
-        'https://api.example.com/schemas/user.json#/properties/name',
-        'https://api.example.com/openapi.json',
-        openApiSchemas,
-      )
-
-      const result3 = convertToLocalRef(
-        'https://api.example.com/schemas/user.json#userProfile',
-        'https://api.example.com/openapi.json',
-        openApiSchemas,
-      )
-
-      expect(result1).toBe('/components/schemas/User')
-      expect(result2).toBe('/components/schemas/User/properties/name')
-      expect(result3).toBe('/components/schemas/User/definitions/UserProfile')
-    })
-
-    it('should handle local component references in OpenAPI', () => {
-      const openApiSchemas = new Map([
-        ['https://api.example.com/openapi.json#userSchema', '/components/schemas/User'],
-        ['https://api.example.com/openapi.json#addressSchema', '/components/schemas/Address'],
-      ])
-
-      const result1 = convertToLocalRef('#userSchema', 'https://api.example.com/openapi.json', openApiSchemas)
-
-      const result2 = convertToLocalRef(
-        '#/components/schemas/User/properties/name',
-        'https://api.example.com/openapi.json',
-        openApiSchemas,
-      )
-
-      expect(result1).toBe('/components/schemas/User')
-      expect(result2).toBe('components/schemas/User/properties/name')
-    })
-  })
-})

package/src/helpers/convert-to-local-ref.ts

@@ -1,43 +0,0 @@
-/**
- * Translates a JSON Reference ($ref) to a local object path within the root schema.
- *
- * @param ref - The JSON Reference string (e.g., "#/foo/bar", "other.json#/baz", "other.json#anchor")
- * @param currentContext - The current base context (usually the $id of the current schema or parent)
- * @param schemas - A map of schema identifiers ($id, $anchor) to their local object paths
- * @returns The local object path as a string, or undefined if the reference cannot be resolved
- */
-export const convertToLocalRef = (
-  ref: string,
-  currentContext: string,
-  schemas: Map<string, string>,
-): string | undefined => {
-  // Split the reference into base URL and path/anchor (e.g., "foo.json#/bar" => ["foo.json", "/bar"])
-  const [baseUrl, pathOrAnchor] = ref.split('#', 2)
-
-  if (baseUrl) {
-    if (!schemas.has(baseUrl)) {
-      return undefined
-    }
-
-    if (!pathOrAnchor) {
-      return schemas.get(baseUrl)
-    }
-
-    // If the pathOrAnchor is a JSON pointer, we need to append it to the baseUrl
-    if (pathOrAnchor.startsWith('/')) {
-      return `${schemas.get(baseUrl)}${pathOrAnchor}`
-    }
-
-    // If the pathOrAnchor is an anchor, we need to return the anchor
-    return schemas.get(`${baseUrl}#${pathOrAnchor}`)
-  }
-
-  if (pathOrAnchor) {
-    if (pathOrAnchor.startsWith('/')) {
-      return pathOrAnchor.slice(1)
-    }
-    return schemas.get(`${currentContext}#${pathOrAnchor}`)
-  }
-
-  return undefined
-}

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

@@ -1,13 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { escapeJsonPointer } from './escape-json-pointer'
-
-describe('escapeJsonPointer', () => {
-  it('should escape a slash', () => {
-    expect(escapeJsonPointer('application/json')).toBe('application~1json')
-  })
-
-  it('should escape multiple slashes', () => {
-    expect(escapeJsonPointer('/api/users/{id}/reports')).toBe('~1api~1users~1{id}~1reports')
-  })
-})

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

@@ -1,8 +0,0 @@
-/**
- * Escapes a JSON pointer string.
- *
- * Example: `/foo/bar~baz` -> `/foo~1bar~0baz`
- */
-export function escapeJsonPointer(str: string) {
-  return str.replace(/~/g, '~0').replace(/\//g, '~1')
-}

package/src/helpers/get-schemas.test.ts

@@ -1,356 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { getId, getSchemas } from './get-schemas'
-
-describe('getId', () => {
-  it('returns the $id string when present', () => {
-    const input = { $id: 'https://example.com/schema' }
-    const result = getId(input)
-    expect(result).toBe('https://example.com/schema')
-  })
-
-  it('returns undefined when $id is not present', () => {
-    const input = { name: 'test' }
-    const result = getId(input)
-    expect(result).toBeUndefined()
-  })
-
-  it('returns undefined when $id is not a string', () => {
-    const input = { $id: 123 }
-    const result = getId(input)
-    expect(result).toBeUndefined()
-  })
-
-  it('returns undefined when $id is null', () => {
-    const input = { $id: null }
-    const result = getId(input)
-    expect(result).toBeUndefined()
-  })
-
-  it('returns undefined when $id is an object', () => {
-    const input = { $id: { nested: 'value' } }
-    const result = getId(input)
-    expect(result).toBeUndefined()
-  })
-
-  it('returns undefined when $id is an array', () => {
-    const input = { $id: ['item1', 'item2'] }
-    const result = getId(input)
-    expect(result).toBeUndefined()
-  })
-
-  it('returns undefined when $id is a boolean', () => {
-    const input = { $id: true }
-    const result = getId(input)
-    expect(result).toBeUndefined()
-  })
-
-  it('returns undefined when $id is an empty string', () => {
-    const input = { $id: '' }
-    const result = getId(input)
-    expect(result).toBe(undefined)
-  })
-})
-
-describe('getSchemas', () => {
-  it('returns empty map for non-object input', () => {
-    const result = getSchemas('string')
-    expect(result.size).toBe(0)
-  })
-
-  it('returns empty map for null input', () => {
-    const result = getSchemas(null)
-    expect(result.size).toBe(0)
-  })
-
-  it('returns empty map for undefined input', () => {
-    const result = getSchemas(undefined)
-    expect(result.size).toBe(0)
-  })
-
-  it('returns empty map for number input', () => {
-    const result = getSchemas(42)
-    expect(result.size).toBe(0)
-  })
-
-  it('returns empty map for boolean input', () => {
-    const result = getSchemas(true)
-    expect(result.size).toBe(0)
-  })
-
-  it('returns empty map for array input', () => {
-    const result = getSchemas([1, 2, 3])
-    expect(result.size).toBe(0)
-  })
-
-  it('collects schema with $id', () => {
-    const input = {
-      $id: 'https://example.com/schema',
-      type: 'object',
-    }
-    const result = getSchemas(input)
-    expect(result.size).toBe(1)
-    expect(result.get('https://example.com/schema')).toBe('')
-  })
-
-  it('collects schema with $anchor', () => {
-    const input = {
-      $anchor: 'myAnchor',
-      type: 'string',
-    }
-    const result = getSchemas(input)
-    expect(result.size).toBe(1)
-    expect(result.get('#myAnchor')).toBe('')
-  })
-
-  it('collects schema with both $id and $anchor', () => {
-    const input = {
-      $id: 'https://example.com/schema',
-      $anchor: 'myAnchor',
-      type: 'object',
-    }
-    const result = getSchemas(input)
-    expect(result.size).toBe(2)
-    expect(result.get('https://example.com/schema')).toBe('')
-    expect(result.get('https://example.com/schema#myAnchor')).toBe('')
-  })
-
-  it('collects nested schemas with $id', () => {
-    const input = {
-      definitions: {
-        user: {
-          $id: 'https://example.com/user',
-          type: 'object',
-        },
-        product: {
-          $id: 'https://example.com/product',
-          type: 'object',
-        },
-      },
-    }
-    const result = getSchemas(input)
-    expect(result.size).toBe(2)
-    expect(result.get('https://example.com/user')).toBe('definitions/user')
-    expect(result.get('https://example.com/product')).toBe('definitions/product')
-  })
-
-  it('collects nested schemas with $anchor', () => {
-    const input = {
-      definitions: {
-        user: {
-          $anchor: 'user',
-          type: 'object',
-        },
-        product: {
-          $anchor: 'product',
-          type: 'object',
-        },
-      },
-    }
-    const result = getSchemas(input)
-    expect(result.size).toBe(2)
-    expect(result.get('#user')).toBe('definitions/user')
-    expect(result.get('#product')).toBe('definitions/product')
-  })
-
-  it('uses parent $id as base for nested $anchor', () => {
-    const input = {
-      $id: 'https://example.com/schema',
-      definitions: {
-        user: {
-          $anchor: 'user',
-          type: 'object',
-        },
-      },
-    }
-    const result = getSchemas(input)
-    expect(result.size).toBe(2)
-    expect(result.get('https://example.com/schema')).toBe('')
-    expect(result.get('https://example.com/schema#user')).toBe('definitions/user')
-  })
-
-  it('handles deeply nested schemas', () => {
-    const input = {
-      components: {
-        schemas: {
-          user: {
-            $id: 'https://example.com/user',
-            properties: {
-              address: {
-                $anchor: 'address',
-                type: 'object',
-              },
-            },
-          },
-        },
-      },
-    }
-    const result = getSchemas(input)
-    expect(result.size).toBe(2)
-    expect(result.get('https://example.com/user')).toBe('components/schemas/user')
-    expect(result.get('https://example.com/user#address')).toBe('components/schemas/user/properties/address')
-  })
-
-  it('handles circular references without infinite loops', () => {
-    const input: any = {
-      $id: 'https://example.com/schema',
-      type: 'object',
-    }
-    input.self = input // Create circular reference
-
-    const result = getSchemas(input)
-    expect(result.size).toBe(1)
-    expect(result.get('https://example.com/schema')).toBe('')
-  })
-
-  it('handles multiple circular references', () => {
-    const input: any = {
-      $id: 'https://example.com/schema',
-      type: 'object',
-      properties: {
-        user: {
-          $anchor: 'user',
-          type: 'object',
-        },
-      },
-    }
-    input.self = input
-    input.properties.user.self = input
-
-    const result = getSchemas(input)
-    expect(result.size).toBe(2)
-    expect(result.get('https://example.com/schema')).toBe('')
-    expect(result.get('https://example.com/schema#user')).toBe('properties/user')
-  })
-
-  it('ignores non-string $id values', () => {
-    const input = {
-      $id: 123,
-      type: 'object',
-    }
-    const result = getSchemas(input)
-    expect(result.size).toBe(0)
-  })
-
-  it('ignores non-string $anchor values', () => {
-    const input = {
-      $anchor: 123,
-      type: 'object',
-    }
-    const result = getSchemas(input)
-    expect(result.size).toBe(0)
-  })
-
-  it('handles empty objects', () => {
-    const input = {}
-    const result = getSchemas(input)
-    expect(result.size).toBe(0)
-  })
-
-  it('handles objects with only primitive values', () => {
-    const input = {
-      name: 'test',
-      age: 25,
-      active: true,
-      tags: ['tag1', 'tag2'],
-    }
-    const result = getSchemas(input)
-    expect(result.size).toBe(0)
-  })
-
-  it('handles mixed primitive and object values', () => {
-    const input = {
-      name: 'test',
-      schema: {
-        $id: 'https://example.com/schema',
-        type: 'object',
-      },
-      age: 25,
-    }
-    const result = getSchemas(input)
-    expect(result.size).toBe(1)
-    expect(result.get('https://example.com/schema')).toBe('schema')
-  })
-
-  it('preserves custom base parameter', () => {
-    const input = {
-      $anchor: 'myAnchor',
-      type: 'object',
-    }
-    const result = getSchemas(input, 'https://custom.com/base')
-    expect(result.size).toBe(1)
-    expect(result.get('https://custom.com/base#myAnchor')).toBe('')
-  })
-
-  it('preserves custom segments parameter', () => {
-    const input = {
-      $id: 'https://example.com/schema',
-      type: 'object',
-    }
-    const result = getSchemas(input, '', ['custom', 'path'])
-    expect(result.size).toBe(1)
-    expect(result.get('https://example.com/schema')).toBe('custom/path')
-  })
-
-  it('reuses existing map when provided', () => {
-    const existingMap = new Map([['existing', 'path']])
-    const input = {
-      $id: 'https://example.com/schema',
-      type: 'object',
-    }
-    const result = getSchemas(input, '', [], existingMap)
-    expect(result).toBe(existingMap)
-    expect(result.size).toBe(2)
-    expect(result.get('existing')).toBe('path')
-    expect(result.get('https://example.com/schema')).toBe('')
-  })
-
-  it('handles complex nested structure with multiple schemas', () => {
-    const input = {
-      $id: 'https://example.com/root',
-      openapi: '3.0.0',
-      info: {
-        title: 'API',
-      },
-      components: {
-        schemas: {
-          user: {
-            $id: 'https://example.com/user',
-            $anchor: 'user',
-            type: 'object',
-            properties: {
-              name: {
-                type: 'string',
-              },
-              address: {
-                $anchor: 'address',
-                type: 'object',
-                properties: {
-                  street: {
-                    type: 'string',
-                  },
-                },
-              },
-            },
-          },
-          product: {
-            $anchor: 'product',
-            type: 'object',
-            properties: {
-              id: {
-                type: 'integer',
-              },
-            },
-          },
-        },
-      },
-    }
-    const result = getSchemas(input)
-    expect(result.size).toBe(5)
-    expect(result.get('https://example.com/root')).toBe('')
-    expect(result.get('https://example.com/user')).toBe('components/schemas/user')
-    expect(result.get('https://example.com/user#user')).toBe('components/schemas/user')
-    expect(result.get('https://example.com/user#address')).toBe('components/schemas/user/properties/address')
-    expect(result.get('https://example.com/root#product')).toBe('components/schemas/product')
-  })
-})