ldkit 0.0.1 → 0.0.2

package/esm/library/comunica/mod.js

@@ -0,0 +1 @@
+export { QueryEngine } from "./bundle.js";

package/esm/library/context.js

@@ -0,0 +1,13 @@
+let defaultContext = undefined;
+export const createContext = (context) => {
+    return context;
+};
+export const createDefaultContext = (context) => {
+    defaultContext = createContext(context);
+};
+export const resolveContext = (context) => {
+    if (!context && !defaultContext) {
+        throw new Error("No context found. Please create a default context or pass one to createResource function");
+    }
+    return context || defaultContext;
+};

package/esm/library/decoder.js

@@ -0,0 +1,203 @@
+import { fromRdf } from "./rdf.js";
+import { ldkit, rdf } from "./namespaces/mod.js";
+class Decoder {
+    constructor(graph, schema, context) {
+        Object.defineProperty(this, "graph", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        this.graph = graph;
+        this.schema = schema;
+        this.context = context;
+    }
+    static decode(graph, schema, context) {
+        return new Decoder(graph, schema, context).decode();
+    }
+    getCachedNode(nodeIri, schema) {
+        if (!this.cache.has(schema)) {
+            this.cache.set(schema, new Map());
+        }
+        return this.cache.get(schema).get(nodeIri);
+    }
+    setCachedNode(nodeIri, schema, decodedNode) {
+        if (!this.cache.has(schema)) {
+            this.cache.set(schema, new Map());
+        }
+        this.cache.get(schema).set(nodeIri, decodedNode);
+    }
+    decode() {
+        const output = [];
+        for (const [iri, properties] of this.graph) {
+            if (properties.has(rdf.type)) {
+                const types = properties.get(rdf.type);
+                for (const type of types) {
+                    if (type.termType === "NamedNode" && type.value === ldkit.Resource) {
+                        output.push(this.decodeNode(iri, this.schema));
+                    }
+                }
+            }
+        }
+        if (this.graph.size > 0 && output.length < 1) {
+            throw new Error(`Unable to decode graph - no resources with type <${ldkit.Resource}> found`);
+        }
+        return output;
+    }
+    decodeNode(nodeIri, schema) {
+        const cachedNode = this.getCachedNode(nodeIri, schema);
+        if (cachedNode) {
+            return cachedNode;
+        }
+        const output = {
+            $id: nodeIri,
+        };
+        const node = this.graph.get(nodeIri);
+        if (!node) {
+            throw new Error(`Error decoding graph, <${nodeIri}> node not found.`);
+        }
+        output.$type = this.decodeNodeType(node);
+        Object.keys(schema).forEach((key) => {
+            if (key === "@type") {
+                return;
+            }
+            const result = this.decodeNodeProperty(nodeIri, node, key, schema[key]);
+            if (result !== undefined) {
+                output[key] = result;
+            }
+        });
+        this.setCachedNode(nodeIri, schema, output);
+        return output;
+    }
+    decodeNodeType(node) {
+        const typeTerms = node.get(rdf.type);
+        if (!typeTerms) {
+            return [];
+        }
+        return typeTerms.reduce((acc, term) => {
+            if (term.value !== ldkit.Resource) {
+                acc.push(term.value);
+            }
+            return acc;
+        }, []);
+    }
+    decodeNodeProperty(nodeIri, node, propertyKey, property) {
+        const terms = node.get(property["@id"]);
+        if (!terms) {
+            if (!property["@optional"]) {
+                // No data, required property
+                throw new Error(`Required property "${propertyKey}" of type <${property["@id"]}> not found on resource <${nodeIri}>`);
+            }
+            else {
+                // No data, optional property
+                return property["@array"] ? [] : undefined;
+            }
+        }
+        if (property["@multilang"]) {
+            if (property["@array"]) {
+                return terms.reduce((acc, term) => {
+                    if (term.termType !== "Literal") {
+                        throw new Error(`Property "${propertyKey}" data type mismatch - expected a literal, but received ${term.termType} instead on resource <${nodeIri}>`);
+                    }
+                    const language = term.language;
+                    if (!acc[language]) {
+                        acc[language] = [];
+                    }
+                    acc[language].push(this.decodeTerm(term));
+                    return acc;
+                }, {});
+            }
+            else {
+                return terms.reduce((acc, term) => {
+                    if (term.termType !== "Literal") {
+                        throw new Error(`Property "${propertyKey}" data type mismatch - expected a literal, but received ${term.termType} instead on resource <${nodeIri}>`);
+                    }
+                    const language = term.language;
+                    if (!acc[language]) {
+                        // If there are multiple strings with the same language detected, selecting only the first one
+                        acc[language] = this.decodeTerm(term);
+                    }
+                    return acc;
+                }, {});
+            }
+        }
+        if (property["@array"]) {
+            if (property["@context"]) {
+                // Collection of resources specified by sub schema
+                return terms.map((term) => {
+                    if (term.termType !== "NamedNode" && term.termType !== "BlankNode") {
+                        throw new Error(`Property "${propertyKey}" data type mismatch - expected a node, but received ${term.termType} instead on resource <${nodeIri}>`);
+                    }
+                    return this.decodeNode(term.value, property["@context"]);
+                });
+            }
+            else {
+                // Collection of literals or named nodes
+                return terms.map((term) => {
+                    if (term.termType !== "Literal" && term.termType !== "NamedNode") {
+                        throw new Error(`Property "${propertyKey}" data type mismatch - expected a literal or named node, but received ${term.termType} instead on resource <${nodeIri}>`);
+                    }
+                    return this.decodeTerm(term);
+                });
+            }
+        }
+        // Single return value expected from this point on
+        if (property["@context"]) {
+            for (const term of terms) {
+                if (term.termType === "NamedNode" || term.termType === "BlankNode") {
+                    return this.decodeNode(term.value, property["@context"]);
+                }
+            }
+            throw new Error(`Property "${propertyKey}" data type mismatch - expected a named node for context on resource <${nodeIri}>`);
+        }
+        const preferredLanguage = this.context.language;
+        if (preferredLanguage) {
+            // Try to find a term that corresponds to the preferred language
+            for (const term of terms) {
+                if (term.termType === "Literal" &&
+                    term.language === preferredLanguage) {
+                    return this.decodeTerm(term);
+                }
+            }
+        }
+        // All options exhausted - return first namedNode or literal if there are multiple
+        for (const term of terms) {
+            if (term.termType === "Literal" || term.termType === "NamedNode") {
+                return this.decodeTerm(term);
+            }
+        }
+        throw new Error(`Property "${propertyKey}" data type mismatch - expected a literal or named node instead on resource <${nodeIri}>`);
+    }
+    decodeTerm(term) {
+        if (term.termType === "NamedNode") {
+            return term.value;
+        }
+        else if (term.termType === "Literal") {
+            return fromRdf(term);
+        }
+        else {
+            throw new Error(`Unsupported term type to resolve: ${term.termType}`);
+        }
+    }
+}
+export const decode = (graph, schema, context) => {
+    return Decoder.decode(graph, schema, context);
+};

package/esm/library/encoder.js

@@ -0,0 +1,116 @@
+import { toRdf, DataFactory, literal, } from "./rdf.js";
+import { rdf, xsd } from "./namespaces/mod.js";
+export const encode = (node, schema, context, variableInitCounter = 0) => {
+    return Encoder.encode(node, schema, context, variableInitCounter);
+};
+class Encoder {
+    constructor(context, variableInitCounter) {
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "df", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new DataFactory({
+                blankNodePrefix: "b",
+            })
+        });
+        Object.defineProperty(this, "variableCounter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.context = context;
+        this.variableCounter = variableInitCounter;
+    }
+    static encode(node, schema, context, variableInitCounter) {
+        return new Encoder(context, variableInitCounter).encode(node, schema);
+    }
+    encode(node, schema) {
+        const nodeId = this.getNodeId(node);
+        this.encodeNode(node, schema, nodeId);
+        return this.output;
+    }
+    push(s, p, o) {
+        this.output.push(this.df.quad(s, p, o));
+    }
+    getNodeId(node) {
+        return node.$id
+            ? this.df.namedNode(node.$id)
+            : this.df.blankNode();
+    }
+    getNodeTypes(node) {
+        if (Array.isArray(node.$type)) {
+            return node.$type;
+        }
+        return node.$type ? [node.$type] : [];
+    }
+    encodeNode(node, schema, nodeId) {
+        this.encodeNodeType(node, schema["@type"], nodeId);
+        Object.keys(schema).forEach((key) => {
+            if (key === "@type") {
+                return;
+            }
+            this.encodeNodeProperty(node[key], schema[key], nodeId);
+        });
+    }
+    encodeNodeType(node, requiredTypes, nodeId) {
+        const finalTypes = new Set([...this.getNodeTypes(node), ...requiredTypes]);
+        finalTypes.forEach((type) => {
+            this.push(nodeId, this.df.namedNode(rdf.type), this.df.namedNode(type));
+        });
+    }
+    encodeNodeProperty(value, property, nodeId) {
+        if (value === undefined) {
+            return;
+        }
+        const propertyId = this.df.namedNode(property["@id"]);
+        if (value === null) {
+            // TODO
+            this.push(nodeId, propertyId, this.df.variable(`v${this.variableCounter++}`));
+            return;
+        }
+        if (property["@multilang"]) {
+            Object.keys(value).forEach((language) => {
+                const languageValue = Array.isArray(value[language])
+                    ? value[language]
+                    : [value[language]];
+                languageValue.forEach((singleValue) => {
+                    this.push(nodeId, propertyId, literal(singleValue, language.length > 0 ? language : undefined));
+                });
+            });
+            return;
+        }
+        const values = Array.isArray(value) ? value : [value];
+        values.forEach((val) => {
+            if (property["@context"]) {
+                const subNodeId = this.getNodeId(val);
+                this.encodeNode(val, property["@context"], subNodeId);
+                this.push(nodeId, propertyId, subNodeId);
+                return;
+            }
+            const propertyType = property["@type"] ?? xsd.string;
+            if (typeof val === "string" && this.context.language) {
+                if (propertyType === xsd.string || propertyType === rdf.langString) {
+                    this.push(nodeId, propertyId, literal(val, this.context.language));
+                    return;
+                }
+            }
+            const rdfValue = toRdf(val, {
+                datatype: this.df.namedNode(property["@type"] ?? xsd.string),
+            });
+            this.push(nodeId, propertyId, rdfValue);
+        });
+    }
+}

package/esm/library/engine.js

@@ -0,0 +1,9 @@
+import { QueryEngine } from "./comunica/mod.js";
+import { from, map, switchMap } from "./rxjs.js";
+import { resolveContext } from "./context.js";
+import { quadsToGraph } from "./rdf.js";
+const engine = new QueryEngine();
+export const booleanQuery = (query, context) => from(engine.queryBoolean(query, resolveContext(context)));
+export const bindingsQuery = (query, context) => from(engine.queryBindings(query, resolveContext(context))).pipe(switchMap((stream) => from(stream.toArray())));
+export const quadsQuery = (query, context) => from(engine.queryQuads(query, resolveContext(context))).pipe(switchMap((stream) => from(stream.toArray())), map((quads) => quadsToGraph(quads)));
+export const updateQuery = (query, context) => from(engine.queryVoid(query, resolveContext(context)));

package/esm/library/namespaces/dcterms.js

@@ -0,0 +1,105 @@
+import { createNamespace } from "./namespace.js";
+export default createNamespace({
+    iri: "http://purl.org/dc/terms/",
+    prefix: "dcterms:",
+    terms: [
+        "Agent",
+        "AgentClass",
+        "BibliographicResource",
+        "Box",
+        "DCMIType",
+        "DDC",
+        "FileFormat",
+        "Frequency",
+        "IMT",
+        "ISO3166",
+        "ISO639-2",
+        "ISO639-3",
+        "Jurisdiction",
+        "LCC",
+        "LCSH",
+        "LicenseDocument",
+        "LinguisticSystem",
+        "Location",
+        "LocationPeriodOrJurisdiction",
+        "MESH",
+        "MediaType",
+        "MediaTypeOrExtent",
+        "MethodOfAccrual",
+        "MethodOfInstruction",
+        "NLM",
+        "Period",
+        "PeriodOfTime",
+        "PhysicalMedium",
+        "PhysicalResource",
+        "Point",
+        "Policy",
+        "ProvenanceStatement",
+        "RFC1766",
+        "RFC3066",
+        "RFC4646",
+        "RFC5646",
+        "RightsStatement",
+        "SizeOrDuration",
+        "Standard",
+        "TGN",
+        "UDC",
+        "URI",
+        "W3CDTF",
+        "abstract",
+        "accessRights",
+        "accrualMethod",
+        "accrualPeriodicity",
+        "accrualPolicy",
+        "alternative",
+        "audience",
+        "available",
+        "bibliographicCitation",
+        "conformsTo",
+        "contributor",
+        "coverage",
+        "created",
+        "creator",
+        "date",
+        "dateAccepted",
+        "dateCopyrighted",
+        "dateSubmitted",
+        "description",
+        "educationLevel",
+        "extent",
+        "format",
+        "hasFormat",
+        "hasPart",
+        "hasVersion",
+        "identifier",
+        "instructionalMethod",
+        "isFormatOf",
+        "isPartOf",
+        "isReferencedBy",
+        "isReplacedBy",
+        "isRequiredBy",
+        "isVersionOf",
+        "issued",
+        "language",
+        "license",
+        "mediator",
+        "medium",
+        "modified",
+        "provenance",
+        "publisher",
+        "references",
+        "relation",
+        "replaces",
+        "requires",
+        "rights",
+        "rightsHolder",
+        "source",
+        "spatial",
+        "subject",
+        "tableOfContents",
+        "temporal",
+        "title",
+        "type",
+        "valid",
+    ],
+});

package/esm/library/namespaces/ldkit.js

@@ -0,0 +1,6 @@
+import { createNamespace } from "./namespace.js";
+export default createNamespace({
+    iri: "http://ldkit/",
+    prefix: "ldkit:",
+    terms: ["Resource"],
+});

package/esm/library/namespaces/mod.js

@@ -0,0 +1,7 @@
+export { default as rdf } from "./rdf.js";
+export { default as dcterms } from "./dcterms.js";
+export { default as ldkit } from "./ldkit.js";
+export { default as schema } from "./schema.js";
+export { default as skos } from "./skos.js";
+export { default as xsd } from "./xsd.js";
+export { createNamespace } from "./namespace.js";

package/esm/library/namespaces/namespace.js

@@ -0,0 +1,11 @@
+export const createNamespace = (namespaceSpec) => Object.assign(
+//<X extends I>(f: [X]) =>
+//  `${namespaceSpec.prefix}:${f}` as `${string & P}${string & X}`,
+namespaceSpec.terms.reduce((acc, term) => {
+    //acc[term] = `${namespaceSpec.prefix}${term}`
+    acc[term] = `${namespaceSpec.iri}${term}`;
+    return acc;
+}, {}), {
+    $prefix: namespaceSpec["prefix"],
+    $iri: namespaceSpec["iri"],
+});

package/esm/library/namespaces/rdf.js

@@ -0,0 +1,29 @@
+import { createNamespace } from "./namespace.js";
+export default createNamespace({
+    iri: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+    prefix: "rdf:",
+    terms: [
+        "Alt",
+        "Bag",
+        "CompoundLiteral",
+        "HTML",
+        "JSON",
+        "List",
+        "PlainLiteral",
+        "Property",
+        "Seq",
+        "Statement",
+        "XMLLiteral",
+        "direction",
+        "first",
+        "langString",
+        "language",
+        "nil",
+        "object",
+        "predicate",
+        "rest",
+        "subject",
+        "type",
+        "value",
+    ],
+});