rdflib.js/src/jsonldparser.js at a6fbe3ec3b184e301c3a6e9b27324084659a5f79 · JavaScriptSolidServer/rdflib.js · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
import jsonld from 'jsonld'

import { arrayToStatements } from './utils'

/**
 * Parses json-ld formatted JS objects to a rdf Term.
 * @param kb - The DataFactory to use.
 * @param obj - The json-ld object to process.
 * @return {Literal|NamedNode|BlankNode|Collection}
 */
export function jsonldObjectToTerm (kb, obj) {
  if (typeof obj === 'string') {
    return kb.rdfFactory.literal(obj)
  }

  if (Object.prototype.hasOwnProperty.call(obj, '@list')) {
    if (kb.rdfFactory.supports["COLLECTIONS"] === true) {
      return listToCollection(kb, obj['@list'])
    }

    return listToStatements(kb, obj)
  }

  if (Object.prototype.hasOwnProperty.call(obj, '@id')) {
    return kb.rdfFactory.namedNode(obj['@id'])
  }

  if (Object.prototype.hasOwnProperty.call(obj, '@language')) {
    return kb.rdfFactory.literal(obj['@value'], obj['@language'])
  }

  if (Object.prototype.hasOwnProperty.call(obj, '@type')) {
    console.log('@type1 ' + Object.keys(obj))
    return kb.rdfFactory.literal(obj['@value'], kb.rdfFactory.namedNode(obj['@type']))
  }

  if (Object.prototype.hasOwnProperty.call(obj, '@value')) {
    return kb.rdfFactory.literal(obj['@value'])
  }

  return kb.rdfFactory.literal(obj)
}

/**
 * Adds the statements in a json-ld list object to {kb}.
 */
function listToStatements (kb, obj) {
  const listId = obj['@id'] ? kb.rdfFactory.namedNode(obj['@id']) : kb.rdfFactory.blankNode()

  const items = obj['@list'].map((listItem => jsonldObjectToTerm(kb, listItem)))
  const statements = arrayToStatements(kb.rdfFactory, listId, items)
  kb.addAll(statements)

  return listId
}

function listToCollection (kb, obj) {
  if (!Array.isArray(obj)) {
    throw new TypeError("Object must be an array")
  }
  return kb.rdfFactory.collection(obj.map((o) => jsonldObjectToTerm(kb, o)))
}

/**
 * Takes a json-ld formatted string {str} and adds its statements to {kb}.
 *
 * Ensure that {kb.rdfFactory} is a DataFactory.
 */
export default function jsonldParser (str, kb, base, callback) {
  const baseString = base && Object.prototype.hasOwnProperty.call(base, 'termType')
    ? base.value
    : base
    console.log(str)

  return jsonld
    .flatten(JSON.parse(str), null, { base: baseString })
    .then((flattened) => flattened.reduce((store, flatResource) => {
      const id = flatResource['@id']
        ? kb.rdfFactory.namedNode(flatResource['@id'])
        : kb.rdfFactory.blankNode()

      for (const property of Object.keys(flatResource)) {
        if (property === '@id') {
          continue
        }
        const value = flatResource[property]
        console.log(property + value)
        if (Array.isArray(value)) {
          for (let i = 0; i < value.length; i++) {
            kb.addStatement(statementFromType(kb, id, property, value[i]))
          }
        } else {
          kb.addStatement(statementFromType(kb, id, property, value))
        }
      }

      return kb
    }, kb))
    .then(callback)
    .catch(callback)
}

/**
 * statement quad depending on @type being a type node or a type value
 * @param kb
 * @param subject id
 * @param property
 * @param value
 * @return quad statement
 */
function statementFromType(kb, id, property, value) {
  const predicateFromType = property === "@type" ? kb.rdfFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type") : kb.rdfFactory.namedNode(property)
  const objectFromType = property === "@type" ? kb.rdfFactory.namedNode(value) : jsonldObjectToTerm(kb, value)
  return kb.rdfFactory.quad(id, predicateFromType, objectFromType)
}