@netwerk-digitaal-erfgoed/network-of-terms-query 6.2.7 → 6.2.9

package/src/query.ts

@@ -0,0 +1,247 @@
+import * as Hoek from '@hapi/hoek';
+import Joi from 'joi';
+import { LoggerPino } from './helpers/logger-pino.js';
+import Pino from 'pino';
+import PrettyMilliseconds from 'pretty-ms';
+import * as RDF from '@rdfjs/types';
+import { Bindings } from '@rdfjs/types';
+import { Term, TermsTransformer } from './terms.js';
+import { QueryMode, queryVariants } from './search/query-mode.js';
+import { Dataset, Distribution, IRI } from './catalog.js';
+import { QueryEngine } from '@comunica/query-sparql';
+import { BindingsFactory } from '@comunica/utils-bindings-factory';
+import { DataFactory } from 'rdf-data-factory';
+import { sourceQueriesHistogram } from './instrumentation.js';
+import { config } from './config.js';
+
+export type TermsResult = Terms | TimeoutError | ServerError;
+
+export class TermsResponse {
+  constructor(
+    readonly result: TermsResult,
+    readonly responseTimeMs: number,
+  ) {}
+}
+
+export class Terms {
+  constructor(
+    readonly distribution: Distribution,
+    readonly terms: Term[],
+  ) {}
+}
+
+export class Error {
+  constructor(
+    readonly distribution: Distribution,
+    readonly message: string,
+  ) {}
+}
+
+export class TimeoutError extends Error {
+  constructor(
+    override readonly distribution: Distribution,
+    timeoutMs: number,
+  ) {
+    super(distribution, `Source timed out after ${timeoutMs}ms`);
+  }
+}
+
+export class ServerError extends Error {}
+
+export class QueryTermsService {
+  private readonly logger: Pino.Logger;
+  private readonly engine: QueryEngine;
+
+  constructor(options: { comunica?: QueryEngine; logger?: Pino.Logger } = {}) {
+    this.engine = options.comunica || new QueryEngine();
+    this.logger = options.logger || Pino.pino();
+  }
+
+  /**
+   * Parameterize the SPARQL query’s limit in two ways:
+   * - as a pre-bound variable ?limit (for GraphDB’s luc:limit, Wikidata and text:query);
+   * - by replacing the #LIMIT# placeholder (for LIMIT 123).
+   */
+  parameterizeLimit(args: {
+    query: string;
+    bindings: Record<string, RDF.Term>;
+    limit: number;
+  }): { queryWithLimit: string; bindingsWithLimit: Record<string, RDF.Term> } {
+    return {
+      queryWithLimit: args.query.replace('#LIMIT#', `LIMIT ${args.limit}`),
+      bindingsWithLimit: {
+        ...args.bindings,
+        limit: dataFactory.literal(
+          args.limit.toString(),
+          dataFactory.namedNode('http://www.w3.org/2001/XMLSchema#integer'),
+        ),
+      },
+    };
+  }
+
+  async search(
+    searchQuery: string,
+    queryMode: QueryMode,
+    dataset: Dataset,
+    distribution: Distribution,
+    limit: number,
+    timeoutMs: number,
+  ): Promise<TermsResponse> {
+    const bindings = [...queryVariants(searchQuery, queryMode)].reduce(
+      (record: Record<string, RDF.Term>, [k, v]) => {
+        record[k] = dataFactory.literal(v);
+        return record;
+      },
+      {},
+    );
+    bindings['datasetUri'] = dataFactory.namedNode(dataset.iri.toString());
+
+    const { queryWithLimit, bindingsWithLimit } = this.parameterizeLimit({
+      query: distribution.searchQuery,
+      bindings,
+      limit,
+    });
+
+    return this.run(
+      // For plain SPARQL LIMIT (LIMIT 123) that cannot be pre-bound
+      queryWithLimit,
+      distribution,
+      timeoutMs,
+      bindingsWithLimit,
+    );
+  }
+
+  async lookup(iris: IRI[], distribution: Distribution, timeoutMs: number) {
+    return this.run(
+      distribution.lookupQuery.replace(
+        '?uris',
+        iris.map((iri) => `<${iri}>`).join(' '),
+      ),
+      distribution,
+      timeoutMs,
+    );
+  }
+
+  async run(
+    query: string,
+    distribution: Distribution,
+    timeoutMs: number,
+    bindings: Record<string, RDF.Term> = {},
+  ): Promise<TermsResponse> {
+    Joi.attempt(
+      timeoutMs,
+      Joi.number()
+        .integer()
+        .min(1)
+        .max(config.MAX_QUERY_TIMEOUT)
+        .default(config.DEFAULT_QUERY_TIMEOUT),
+    );
+
+    const timer = new Hoek.Bench();
+    const logger = new LoggerPino({ logger: this.logger });
+    // Extract HTTP credentials if the distribution URL contains any.
+    const url = new URL(distribution.endpoint.toString());
+    this.logger.info(`Querying "${url}" with "${query}"...`);
+    const quadStream = await this.engine.queryQuads(query, {
+      log: logger,
+      httpAuth: url.username === '' ? '' : url.username + ':' + url.password,
+      httpTimeout: timeoutMs,
+      noCache: true,
+      sources: [
+        {
+          type: 'sparql',
+          value: url.origin + url.pathname,
+        },
+      ],
+      initialBindings: bindingsFactory.fromRecord(
+        bindings,
+      ) as unknown as Bindings,
+    });
+
+    return new Promise((resolve) => {
+      const termsTransformer = new TermsTransformer();
+      quadStream.on('error', (error) => {
+        const elapsed = Math.round(timer.elapsed());
+        this.logger.error(
+          `An error occurred when querying "${distribution.endpoint}": ${error} with %o`,
+          error,
+        );
+
+        if (error.message.startsWith('Fetch timed out')) {
+          sourceQueriesHistogram.record(Math.round(timer.elapsed()), {
+            distribution: distribution.iri.toString(),
+            error: 'TimeoutError',
+          });
+          resolve(
+            new TermsResponse(
+              new TimeoutError(distribution, timeoutMs),
+              elapsed,
+            ),
+          );
+        } else {
+          sourceQueriesHistogram.record(Math.round(timer.elapsed()), {
+            distribution: distribution.iri.toString(),
+            error: 'ServerError',
+          });
+          resolve(
+            new TermsResponse(
+              new ServerError(
+                distribution,
+                obfuscateHttpCredentials(error.message),
+              ),
+              elapsed,
+            ),
+          );
+        }
+      });
+      quadStream.on('data', (quad: RDF.Quad) => {
+        termsTransformer.fromQuad(quad);
+      });
+      quadStream.on('end', () => {
+        const terms = termsTransformer
+          .asArray()
+          .sort(byScoreThenAlphabetically);
+        this.logger.info(
+          `Found ${terms.length} terms matching "${query}" in "${
+            distribution.endpoint
+          }" in ${PrettyMilliseconds(timer.elapsed())}`,
+        );
+        sourceQueriesHistogram.record(Math.round(timer.elapsed()), {
+          distribution: distribution.iri.toString(),
+        });
+        resolve(
+          new TermsResponse(
+            new Terms(distribution, terms),
+            Math.round(timer.elapsed()),
+          ),
+        );
+      });
+    });
+  }
+}
+
+const byScoreThenAlphabetically = (a: Term, b: Term) => {
+  const scoreA = parseFloat(a.score?.value ?? '0');
+  const scoreB = parseFloat(b.score?.value ?? '0');
+  if (scoreA === scoreB) {
+    return alphabeticallyByLabels(a, b);
+  } else {
+    return scoreA < scoreB ? 1 : -1;
+  }
+};
+
+const alphabeticallyByLabels = (a: Term, b: Term) => {
+  const prefLabelA = a.prefLabels[0]?.value ?? '';
+  const altLabelA = a.altLabels[0]?.value ?? '';
+  const sortLabelA = prefLabelA + altLabelA;
+  const prefLabelB = b.prefLabels[0]?.value ?? '';
+  const altLabelB = b.altLabels[0]?.value ?? '';
+  const sortLabelB = prefLabelB + altLabelB;
+  return sortLabelA.localeCompare(sortLabelB);
+};
+
+const dataFactory = new DataFactory();
+const bindingsFactory = new BindingsFactory(dataFactory);
+
+const obfuscateHttpCredentials = (message: string) =>
+  message.replace(/(https?):\/\/.+:.+@/, '$1://***@');

package/src/search/query-mode.ts

@@ -0,0 +1,54 @@
+export enum QueryMode {
+  RAW = 'raw',
+  OPTIMIZED = 'optimized',
+}
+
+export function queryVariants(query: string, type: QueryMode) {
+  switch (type) {
+    case QueryMode.RAW:
+      return new Map([
+        ['query', query],
+        ['virtuosoQuery', query],
+      ]);
+    case QueryMode.OPTIMIZED:
+      return new Map([
+        ['query', stringQuery(query)],
+        ['virtuosoQuery', virtuosoQuery(stringQuery(query))],
+      ]);
+  }
+}
+
+const stringQuery = (query: string) =>
+  query.toLowerCase().replace(/\s+/g, ' ').trim();
+
+const virtuosoQuery = (query: string) =>
+  join(quote(filterStopWords(split(escape(query)))));
+
+const escape = (query: string) => query.replace(/'/g, "\\'");
+
+const split = (query: string) => query.split(/\s+/);
+
+/**
+ * Quote parts that are not boolean operators.
+ */
+const quote = (queryParts: string[]) =>
+  queryParts.map((part) => (isBooleanOperator(part) ? part : `'${part}'`));
+
+const filterStopWords = (queryParts: string[]) =>
+  queryParts.filter((part) => part !== '&');
+
+/**
+ * Join query parts with boolean AND if they are not yet connected with a boolean.
+ */
+const join = (queryParts: string[]) =>
+  queryParts.reduce((previousValue, currentValue, currentIndex, array) => {
+    const previous = array[currentIndex - 1];
+    if (!isBooleanOperator(previous) && !isBooleanOperator(currentValue)) {
+      return `${previousValue} AND ${currentValue}`;
+    }
+
+    return `${previousValue} ${currentValue}`;
+  });
+
+const isBooleanOperator = (maybeBool: string) =>
+  maybeBool.toLowerCase() === 'and' || maybeBool.toLowerCase() === 'or';

package/src/terms.ts

@@ -0,0 +1,141 @@
+import type RDF from '@rdfjs/types';
+
+export class Term {
+  constructor(
+    readonly id: RDF.Term,
+    readonly type: RDF.Term | undefined,
+    readonly prefLabels: RDF.Literal[],
+    readonly altLabels: RDF.Literal[],
+    readonly hiddenLabels: RDF.Literal[],
+    readonly scopeNotes: RDF.Literal[],
+    readonly seeAlso: RDF.NamedNode[],
+    readonly broaderTerms: RelatedTerm[],
+    readonly narrowerTerms: RelatedTerm[],
+    readonly relatedTerms: RelatedTerm[],
+    readonly exactMatches: RelatedTerm[],
+    readonly datasetIri: RDF.Term | undefined,
+    readonly score: RDF.Literal | undefined,
+  ) {}
+}
+
+export class RelatedTerm {
+  constructor(
+    readonly id: RDF.Term,
+    readonly prefLabels: RDF.Literal[],
+  ) {}
+}
+
+class SparqlResultTerm {
+  constructor(readonly id: RDF.Term) {}
+  type: RDF.Term | undefined = undefined;
+  prefLabels: RDF.Literal[] = [];
+  altLabels: RDF.Literal[] = [];
+  hiddenLabels: RDF.Literal[] = [];
+  scopeNotes: RDF.Literal[] = [];
+  seeAlso: RDF.NamedNode[] = [];
+  broaderTerms: RDF.Term[] = [];
+  narrowerTerms: RDF.Term[] = [];
+  relatedTerms: RDF.Term[] = [];
+  exactMatches: RDF.Term[] = [];
+  inScheme: RDF.Term | undefined = undefined;
+  score: RDF.Literal | undefined = undefined;
+}
+
+export class TermsTransformer {
+  private termsIris: Set<string> = new Set();
+  private termsMap: Map<string, SparqlResultTerm> = new Map();
+  private readonly predicateToPropertyMap = new Map<string, string>([
+    ['http://www.w3.org/1999/02/22-rdf-syntax-ns#type', 'type'],
+    ['http://www.w3.org/2000/01/rdf-schema#seeAlso', 'seeAlso'],
+    ['http://www.w3.org/2004/02/skos/core#prefLabel', 'prefLabels'],
+    ['http://www.w3.org/2008/05/skos#prefLabel', 'prefLabels'],
+    ['http://www.w3.org/2004/02/skos/core#altLabel', 'altLabels'],
+    ['http://www.w3.org/2008/05/skos#altLabel', 'altLabels'],
+    ['http://www.w3.org/2004/02/skos/core#hiddenLabel', 'hiddenLabels'],
+    ['http://www.w3.org/2008/05/skos#hiddenLabel', 'hiddenLabels'],
+    ['http://www.w3.org/2004/02/skos/core#scopeNote', 'scopeNotes'],
+    ['http://www.w3.org/2008/05/skos#scopeNote', 'scopeNotes'],
+    ['http://www.w3.org/2004/02/skos/core#broader', 'broaderTerms'],
+    ['http://www.w3.org/2008/05/skos#broader', 'broaderTerms'],
+    ['http://www.w3.org/2004/02/skos/core#narrower', 'narrowerTerms'],
+    ['http://www.w3.org/2008/05/skos#narrower', 'narrowerTerms'],
+    ['http://www.w3.org/2004/02/skos/core#related', 'relatedTerms'],
+    ['http://www.w3.org/2008/05/skos#related', 'relatedTerms'],
+    ['http://www.w3.org/2004/02/skos/core#exactMatch', 'exactMatches'],
+    ['http://www.w3.org/2008/05/skos#exactMatch', 'exactMatches'],
+    ['http://www.w3.org/2004/02/skos/core#inScheme', 'inScheme'],
+    ['http://purl.org/voc/vrank#simpleRank', 'score'],
+  ]);
+
+  fromQuad(quad: RDF.Quad): void {
+    const subject = quad.subject;
+    const propertyName = this.predicateToPropertyMap.get(quad.predicate.value);
+    const currentTerm =
+      this.termsMap.get(subject.value) ?? new SparqlResultTerm(subject);
+    this.termsMap.set(subject.value, currentTerm);
+
+    // skos:Concepts are the top-level search results, which we track in termsIris.
+    if (
+      propertyName === 'type' &&
+      (quad.object.value === 'http://www.w3.org/2004/02/skos/core#Concept' ||
+        quad.object.value === 'http://www.w3.org/2008/05/skos#Concept')
+    ) {
+      this.termsIris.add(subject.value);
+    }
+
+    if (propertyName !== undefined) {
+      const propertyValue = (currentTerm as any)[propertyName]; // eslint-disable-line @typescript-eslint/no-explicit-any
+      if (Array.isArray(propertyValue)) {
+        // Prevent duplicate prefLabel values due to duplicate quads.
+        if (!propertyValue.find((value) => value.equals(quad.object))) {
+          propertyValue.push(quad.object);
+        }
+      } else {
+        (currentTerm as any)[propertyName] = quad.object; // eslint-disable-line @typescript-eslint/no-explicit-any
+      }
+    }
+  }
+
+  asArray(): Term[] {
+    return [...this.termsIris].map((iri) => {
+      const term = this.termsMap.get(iri)!;
+
+      return new Term(
+        term.id,
+        term.type,
+        term.prefLabels,
+        term.altLabels,
+        term.hiddenLabels,
+        term.scopeNotes,
+        term.seeAlso,
+        this.mapRelatedTerms(term.broaderTerms).sort(alphabeticallyByPrefLabel),
+        this.mapRelatedTerms(term.narrowerTerms).sort(
+          alphabeticallyByPrefLabel,
+        ),
+        this.mapRelatedTerms(term.relatedTerms).sort(alphabeticallyByPrefLabel),
+        this.mapRelatedTerms(term.exactMatches).sort(alphabeticallyByPrefLabel),
+        term.inScheme,
+        term.score,
+      );
+    });
+  }
+
+  /**
+   * Map related IRIs to their related terms, making sure to only accept complete related terms.
+   *
+   * Related terms can be incomplete because of the SPARQL query limit (see
+   * https://github.com/netwerk-digitaal-erfgoed/network-of-terms/issues/36).
+   */
+  private mapRelatedTerms = (terms: RDF.Term[]) =>
+    terms.reduce((acc: RelatedTerm[], iri: RDF.Term) => {
+      const term = this.termsMap.get(iri.value);
+      acc.push(new RelatedTerm(iri, term?.prefLabels ?? []));
+      return acc;
+    }, []);
+}
+
+const alphabeticallyByPrefLabel = (a: RelatedTerm, b: RelatedTerm) => {
+  const prefLabelA = a.prefLabels[0]?.value ?? '';
+  const prefLabelB = b.prefLabels[0]?.value ?? '';
+  return prefLabelA.localeCompare(prefLabelB);
+};

package/src/test-utils.ts

@@ -0,0 +1,207 @@
+import {
+  Catalog,
+  Dataset,
+  Feature,
+  FeatureType,
+  Organization,
+  SparqlDistribution,
+} from './index.js';
+import { setup, teardown as teardownServer } from 'jest-dev-server';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { SpawndChildProcess } from 'spawnd';
+import nock from 'nock';
+
+nock('https://example.com')
+  .post('/distributions/timeout')
+  .delay(3000)
+  .reply(200)
+  .persist();
+
+export const teardown = async () => {
+  await teardownServer(servers);
+};
+
+let servers: SpawndChildProcess[];
+export const testCatalog = (port: number) =>
+  new Catalog([
+    new Dataset(
+      'https://data.rkd.nl/rkdartists',
+      { nl: 'RKDartists', en: 'RKDartists' },
+      {
+        nl: 'Biografische gegevens van Nederlandse en buitenlandse kunstenaars van de middeleeuwen tot heden',
+      },
+      ['https://data.cultureelerfgoed.nl/termennetwerk/onderwerpen/Personen'],
+      ['https://example.com/resources/'],
+      'https://example.com/rkdartists',
+      ['en', 'nl'],
+      [
+        new Organization(
+          'https://rkd.nl',
+          { nl: 'RKD – Nederlands Instituut voor Kunstgeschiedenis' },
+          { nl: 'RKD' },
+        ),
+      ],
+      [
+        new SparqlDistribution(
+          'https://data.netwerkdigitaalerfgoed.nl/rkd/rkdartists/sparql',
+          `http://localhost:${port}/sparql`,
+          `
+          PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
+          CONSTRUCT { 
+            ?s ?p ?o 
+          }
+          WHERE {
+            {
+              SELECT DISTINCT ?s WHERE {
+                ?s ?labelPredicate ?label .
+                VALUES ?labelPredicate { skos:prefLabel skos:altLabel skos:hiddenLabel }
+                FILTER (regex(?label, ?query, "i"))            
+              }
+              #LIMIT#
+            }
+              
+            ?s ?p ?o .
+           
+            OPTIONAL { 
+              ?s skos:exactMatch ?match .
+              ?match skos:prefLabel ?match_label .
+            }  
+          }`,
+          `
+          PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
+          CONSTRUCT {
+            ?s ?p ?o ;
+              skos:broader ?broader_uri ;
+              skos:narrower ?narrower_uri ;
+              skos:related ?related_uri ;
+              skos:inScheme <https://data.rkd.nl/rkdartists> .
+            ?broader_uri skos:prefLabel ?broader_prefLabel .
+            ?narrower_uri skos:prefLabel ?narrower_prefLabel .
+            ?related_uri skos:prefLabel ?related_prefLabel .
+          } 
+          WHERE { 
+            ?s ?p ?o.
+            VALUES ?s { ?uris }
+            OPTIONAL { 
+              ?s skos:broader ?broader_uri.
+              ?broader_uri skos:prefLabel ?broader_prefLabel. 
+            } 
+            OPTIONAL { 
+              ?s skos:narrower ?narrower_uri.
+              ?narrower_uri skos:prefLabel ?narrower_prefLabel. 
+            } 
+            OPTIONAL { 
+              ?s skos:related ?related_uri.
+              ?related_uri skos:prefLabel ?related_prefLabel. 
+            } 
+          }`,
+          [
+            new Feature(
+              FeatureType.RECONCILIATION,
+              new URL('https://example.com/reconcile/rkd'),
+            ),
+          ],
+        ),
+      ],
+      { nl: 'RKD' },
+    ),
+    new Dataset(
+      'https://data.cultureelerfgoed.nl/term/id/cht',
+      { nl: 'Cultuurhistorische Thesaurus' },
+      { nl: 'Onderwerpen voor het beschrijven van cultureel erfgoed' },
+      [
+        'https://data.cultureelerfgoed.nl/termennetwerk/onderwerpen/Abstracte-begrippen',
+      ],
+      ['https://data.cultureelerfgoed.nl/term/id/cht/'],
+      'https://example.com/cht',
+      ['nl'],
+      [
+        new Organization(
+          'https://www.cultureelerfgoed.nl',
+          { nl: 'Rijksdienst voor het Cultureel Erfgoed' },
+          { nl: 'RCE' },
+        ),
+      ],
+      [
+        new SparqlDistribution(
+          'https://example.com/distributions/endpoint-error',
+          'http://does-not-resolve',
+          'CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o }',
+          'CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o }',
+          [
+            new Feature(
+              FeatureType.RECONCILIATION,
+              new URL('https://example.com/reconcile/cht'),
+            ),
+          ],
+        ),
+      ],
+    ),
+    new Dataset(
+      'http://vocab.getty.edu/aat',
+      { nl: 'Art & Architecture Thesaurus' },
+      {
+        nl: 'Onderwerpen voor het beschrijven van architectuur-, kunst- en cultuurhistorische collecties',
+      },
+      [
+        'https://data.cultureelerfgoed.nl/termennetwerk/onderwerpen/Abstracte-begrippen',
+      ],
+      ['http://vocab.getty.edu/aat/'],
+      'https://example.com/aat',
+      ['nl'],
+      [
+        new Organization(
+          'http://www.getty.edu/research/',
+          { nl: 'Getty Research Institute' },
+          { nl: 'Getty' },
+        ),
+      ],
+      [
+        new SparqlDistribution(
+          'https://example.com/distributions/timeout',
+          'https://example.com/distributions/timeout',
+          'CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o }',
+          'CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o }',
+        ),
+      ],
+    ),
+    new Dataset(
+      'http://data.beeldengeluid.nl/gtaa/Persoonsnamen',
+      { nl: 'GTAA: persoonsnamen' },
+      { nl: 'Personen voor het beschrijven van audiovisueel materiaal' },
+      [
+        'https://data.cultureelerfgoed.nl/termennetwerk/onderwerpen/Abstracte-begrippen',
+      ],
+      ['http://data.beeldengeluid.nl/gtaa/'],
+      'https://example.com/gtaa',
+      ['nl'],
+      [
+        new Organization(
+          'https://www.beeldengeluid.nl/',
+          { nl: 'Nederlands Instituut voor Beeld en Geluid' },
+          { nl: 'Beeld en Geluid' },
+        ),
+      ],
+      [
+        new SparqlDistribution(
+          'https://data.beeldengeluid.nl/id/datadownload/0026',
+          'https://username:password@gtaa.apis.beeldengeluid.nl/sparql',
+          'CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o }',
+          'CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o }',
+        ),
+      ],
+    ),
+  ]);
+
+export async function startDistributionSparqlEndpoint(
+  port: number,
+): Promise<void> {
+  servers = await setup({
+    command: `npx --no comunica-sparql-file-http ${dirname(
+      fileURLToPath(import.meta.url),
+    )}/../test/fixtures/terms.ttl -p ${port}`,
+    port,
+    launchTimeout: 20000,
+  });
+}

package/test/fixtures/terms.ttl

@@ -0,0 +1,46 @@
+@prefix skos: <http://www.w3.org/2004/02/skos/core#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix vrank: <http://purl.org/voc/vrank#> .
+
+<https://example.com/resources/artwork>
+    a skos:Concept ;
+    skos:prefLabel "Nachtwacht"@nl, "The Night Watch"@en ;
+    skos:altLabel "Nachtwacht alt"@nl, "Night Watch alt"@en ;
+    skos:scopeNote "One of the most famous Dutch paintings"@en ;
+    skos:hiddenLabel "art" ;
+    skos:broader <https://example.com/resources/2> ;
+    skos:related <https://example.com/resources/painter> ,
+        <https://example.com/resources/painting> ,
+        <https://example.com/resources/art> ;
+    skos:exactMatch <https://example.com/resources/match> ;
+    skos:ignored "Not used by Network of Terms" ;
+    rdfs:seeAlso <https://example.com/html/artwork> ;
+    vrank:simpleRank 18.0 .
+
+<https://example.com/resources/painting>
+    a <http://www.w3.org/2008/05/skos#Concept> ;
+    skos:altLabel
+        "painted things that can be beautiful"@en ,
+        "another altLabel"@en ,
+        "mooie geschilderde dingen"@nl ,
+        "en nog meer"@nl ;
+    skos:related <https://example.com/resources/art> ;
+    skos:broader <https://example.com/resources/art> .
+
+<https://example.com/resources/painter>
+    a <http://www.w3.org/2008/05/skos#Concept> ;
+    skos:prefLabel "Rembrandt"@en ;
+    vrank:simpleRank 20.5 .
+
+<https://example.com/resources/art>
+    a skos:Concept ;
+    skos:prefLabel "All things art"@en, "Kunstige dingen" ; # last value is fallback and has no language tag on purpose
+    skos:altLabel "Art"@en ;
+    skos:narrower <https://example.com/resources/artwork> .
+
+<https://example.com/resources/alphabet>
+    a skos:Concept ;
+    skos:altLabel "Resource without prefLabel"@en .
+
+<https://example.com/resources/match>
+    skos:prefLabel "Exact match"@en .