alcaeus/ResourceStore.js

Hydra Core hypermedia-aware client library

import deleteMatch from 'rdf-dataset-ext/deleteMatch.js';
import addAll from 'rdf-dataset-ext/addAll.js';
import CachedResourceFactoryImpl from 'alcaeus-model/ResourceFactory.js';
import ResourceRepresentationImpl from './ResourceRepresentation.js';
export default class ResourceStoreImpl {
    constructor({ dataset, inferences, factory, environment }) {
        this.dataset = dataset;
        this.inferences = inferences;
        if (!factory) {
            factory = environment.rdfine().factory;
        }
        this.factory = factory instanceof CachedResourceFactoryImpl ? factory : new CachedResourceFactoryImpl(factory, environment);
        this.environment = environment;
        this.rootNodes = environment.termMap();
        this.responses = environment.termMap();
    }
    clone() {
        return new ResourceStoreImpl({
            inferences: this.inferences,
            dataset: this.environment.dataset([...this.dataset]),
            factory: this.factory.clone(),
            environment: this.environment,
        });
    }
    get(idOrPointer) {
        let graph;
        let node;
        if ('termType' in idOrPointer) {
            graph = idOrPointer;
            node = this.environment.clownface({ dataset: this.dataset, graph });
        }
        else {
            graph = idOrPointer._context[0].graph;
            node = idOrPointer;
        }
        const response = this.responses.get(graph);
        if (!response) {
            return undefined;
        }
        const rootNode = this.rootNodes.get(graph) || graph;
        return {
            response,
            representation: new ResourceRepresentationImpl(node, this.environment, rootNode),
        };
    }
    async set(graph, { response, dataset, rootResource }) {
        this.factory.removeCache(graph);
        const inferredQuads = this.environment.dataset();
        this.inferences.forEach(inferenceOver => addAll(inferredQuads, [...inferenceOver(dataset, this.environment)]));
        addAll(deleteMatch(this.dataset, undefined, undefined, undefined, graph), [...dataset].map(this.tripleToQuad(graph)));
        addAll(this.dataset, [...inferredQuads].map(this.tripleToQuad(graph)));
        this.responses.set(graph, response);
        if (rootResource) {
            this.rootNodes.set(graph, rootResource);
        }
    }
    tripleToQuad(graph) {
        return (triple) => {
            return this.environment.quad(triple.subject, triple.predicate, triple.object, graph);
        };
    }
}