| Server IP : 167.235.224.122 / Your IP : 216.73.216.110 Web Server : Apache/2.4.58 (Ubuntu) System : Linux newplayground 6.8.0-136-generic #136-Ubuntu SMP PREEMPT_DYNAMIC Wed Jul 1 21:33:11 UTC 2026 aarch64 User : deploy ( 1000) PHP Version : 8.4.23 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /var/www/html/openskillpaths/node_modules/json-schema-ref-resolver/ |
Upload File : |
'use strict'
const { dequal: deepEqual } = require('dequal')
const jsonSchemaRefSymbol = Symbol.for('json-schema-ref')
class RefResolver {
#schemas
#derefSchemas
#insertRefSymbol
#allowEqualDuplicates
#cloneSchemaWithoutRefs
constructor (opts = {}) {
this.#schemas = {}
this.#derefSchemas = {}
this.#insertRefSymbol = opts.insertRefSymbol ?? false
this.#allowEqualDuplicates = opts.allowEqualDuplicates ?? true
this.#cloneSchemaWithoutRefs = opts.cloneSchemaWithoutRefs ?? false
}
addSchema (schema, rootSchemaId, isRootSchema = true) {
if (isRootSchema) {
if (schema.$id !== undefined && schema.$id.charAt(0) !== '#') {
// Schema has an $id that is not an anchor
rootSchemaId = schema.$id
} else {
// Schema has no $id or $id is an anchor
this.#insertSchemaBySchemaId(schema, rootSchemaId)
}
}
const schemaId = schema.$id
if (schemaId !== undefined && typeof schemaId === 'string') {
if (schemaId.charAt(0) === '#') {
this.#insertSchemaByAnchor(schema, rootSchemaId, schemaId)
} else {
this.#insertSchemaBySchemaId(schema, schemaId)
rootSchemaId = schemaId
}
}
const ref = schema.$ref
if (ref !== undefined && typeof ref === 'string') {
const { refSchemaId, refJsonPointer } = this.#parseSchemaRef(ref, rootSchemaId)
this.#schemas[rootSchemaId].refs.push({
schemaId: refSchemaId,
jsonPointer: refJsonPointer
})
}
for (const key in schema) {
if (typeof schema[key] === 'object' && schema[key] !== null) {
this.addSchema(schema[key], rootSchemaId, false)
}
}
}
getSchema (schemaId, jsonPointer = '#') {
const schema = this.#schemas[schemaId]
if (schema === undefined) {
throw new Error(
`Cannot resolve ref "${schemaId}${jsonPointer}". Schema with id "${schemaId}" is not found.`
)
}
if (schema.anchors[jsonPointer] !== undefined) {
return schema.anchors[jsonPointer]
}
return getDataByJSONPointer(schema.schema, jsonPointer)
}
hasSchema (schemaId) {
return this.#schemas[schemaId] !== undefined
}
getSchemaRefs (schemaId) {
const schema = this.#schemas[schemaId]
if (schema === undefined) {
throw new Error(`Schema with id "${schemaId}" is not found.`)
}
return schema.refs
}
getSchemaDependencies (schemaId, dependencies = {}) {
const schema = this.#schemas[schemaId]
for (const ref of schema.refs) {
const dependencySchemaId = ref.schemaId
if (
dependencySchemaId === schemaId ||
dependencies[dependencySchemaId] !== undefined
) continue
dependencies[dependencySchemaId] = this.getSchema(dependencySchemaId)
this.getSchemaDependencies(dependencySchemaId, dependencies)
}
return dependencies
}
derefSchema (schemaId) {
if (this.#derefSchemas[schemaId] !== undefined) return
const schema = this.#schemas[schemaId]
if (schema === undefined) {
throw new Error(`Schema with id "${schemaId}" is not found.`)
}
if (!this.#cloneSchemaWithoutRefs && schema.refs.length === 0) {
this.#derefSchemas[schemaId] = {
schema: schema.schema,
anchors: schema.anchors
}
}
const refs = []
this.#addDerefSchema(schema.schema, schemaId, true, refs)
const dependencies = this.getSchemaDependencies(schemaId)
for (const schemaId in dependencies) {
const schema = dependencies[schemaId]
this.#addDerefSchema(schema, schemaId, true, refs)
}
for (const ref of refs) {
const {
refSchemaId,
refJsonPointer
} = this.#parseSchemaRef(ref.ref, ref.sourceSchemaId)
const targetSchema = this.getDerefSchema(refSchemaId, refJsonPointer)
if (targetSchema === null) {
throw new Error(
`Cannot resolve ref "${ref.ref}". Ref "${refJsonPointer}" is not found in schema "${refSchemaId}".`
)
}
ref.targetSchema = targetSchema
ref.targetSchemaId = refSchemaId
}
for (const ref of refs) {
this.#resolveRef(ref, refs)
}
}
getDerefSchema (schemaId, jsonPointer = '#') {
let derefSchema = this.#derefSchemas[schemaId]
if (derefSchema === undefined) {
this.derefSchema(schemaId)
derefSchema = this.#derefSchemas[schemaId]
}
if (derefSchema.anchors[jsonPointer] !== undefined) {
return derefSchema.anchors[jsonPointer]
}
return getDataByJSONPointer(derefSchema.schema, jsonPointer)
}
#parseSchemaRef (ref, schemaId) {
const sharpIndex = ref.indexOf('#')
if (sharpIndex === -1) {
return { refSchemaId: ref, refJsonPointer: '#' }
}
if (sharpIndex === 0) {
return { refSchemaId: schemaId, refJsonPointer: ref }
}
return {
refSchemaId: ref.slice(0, sharpIndex),
refJsonPointer: ref.slice(sharpIndex)
}
}
#addDerefSchema (schema, rootSchemaId, isRootSchema, refs = []) {
const derefSchema = Array.isArray(schema) ? [...schema] : { ...schema }
if (isRootSchema) {
if (schema.$id !== undefined && schema.$id.charAt(0) !== '#') {
// Schema has an $id that is not an anchor
rootSchemaId = schema.$id
} else {
// Schema has no $id or $id is an anchor
this.#insertDerefSchemaBySchemaId(derefSchema, rootSchemaId)
}
}
const schemaId = derefSchema.$id
if (schemaId !== undefined && typeof schemaId === 'string') {
if (schemaId.charAt(0) === '#') {
this.#insertDerefSchemaByAnchor(derefSchema, rootSchemaId, schemaId)
} else {
this.#insertDerefSchemaBySchemaId(derefSchema, schemaId)
rootSchemaId = schemaId
}
}
if (derefSchema.$ref !== undefined) {
refs.push({
ref: derefSchema.$ref,
sourceSchemaId: rootSchemaId,
sourceSchema: derefSchema
})
}
for (const key in derefSchema) {
const value = derefSchema[key]
if (typeof value === 'object' && value !== null) {
derefSchema[key] = this.#addDerefSchema(value, rootSchemaId, false, refs)
}
}
return derefSchema
}
#resolveRef (ref, refs) {
const { sourceSchema, targetSchema } = ref
if (!sourceSchema.$ref) return
if (this.#insertRefSymbol) {
sourceSchema[jsonSchemaRefSymbol] = sourceSchema.$ref
}
delete sourceSchema.$ref
if (targetSchema.$ref) {
const targetSchemaRef = refs.find(ref => ref.sourceSchema === targetSchema)
this.#resolveRef(targetSchemaRef, refs)
}
for (const key in targetSchema) {
if (key === '$id') continue
if (sourceSchema[key] !== undefined) {
if (deepEqual(sourceSchema[key], targetSchema[key])) continue
throw new Error(
`Cannot resolve ref "${ref.ref}". Property "${key}" already exists in schema "${ref.sourceSchemaId}".`
)
}
sourceSchema[key] = targetSchema[key]
}
ref.isResolved = true
}
#insertSchemaBySchemaId (schema, schemaId) {
const foundSchema = this.#schemas[schemaId]
if (foundSchema !== undefined) {
if (this.#allowEqualDuplicates && deepEqual(schema, foundSchema.schema)) return
throw new Error(`There is already another schema with id "${schemaId}".`)
}
this.#schemas[schemaId] = { schema, anchors: {}, refs: [] }
}
#insertSchemaByAnchor (schema, schemaId, anchor) {
const { anchors } = this.#schemas[schemaId]
if (anchors[anchor] !== undefined) {
throw new Error(`There is already another anchor "${anchor}" in schema "${schemaId}".`)
}
anchors[anchor] = schema
}
#insertDerefSchemaBySchemaId (schema, schemaId) {
const foundSchema = this.#derefSchemas[schemaId]
if (foundSchema !== undefined) return
this.#derefSchemas[schemaId] = { schema, anchors: {} }
}
#insertDerefSchemaByAnchor (schema, schemaId, anchor) {
const { anchors } = this.#derefSchemas[schemaId]
anchors[anchor] = schema
}
}
function getDataByJSONPointer (data, jsonPointer) {
const parts = jsonPointer.split('/')
let current = data
for (const part of parts) {
if (part === '' || part === '#') continue
if (typeof current !== 'object' || current === null) {
return null
}
current = current[part]
}
return current ?? null
}
module.exports = { RefResolver }