ldkit 0.0.1 → 0.0.2

package/script/library/comunica/mod.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryEngine = void 0;
+var bundle_js_1 = require("./bundle.js");
+Object.defineProperty(exports, "QueryEngine", { enumerable: true, get: function () { return bundle_js_1.QueryEngine; } });

package/script/library/context.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveContext = exports.createDefaultContext = exports.createContext = void 0;
+let defaultContext = undefined;
+const createContext = (context) => {
+    return context;
+};
+exports.createContext = createContext;
+const createDefaultContext = (context) => {
+    defaultContext = (0, exports.createContext)(context);
+};
+exports.createDefaultContext = createDefaultContext;
+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;
+};
+exports.resolveContext = resolveContext;

package/script/library/decoder.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = void 0;
+const rdf_js_1 = require("./rdf.js");
+const mod_js_1 = require("./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(mod_js_1.rdf.type)) {
+                const types = properties.get(mod_js_1.rdf.type);
+                for (const type of types) {
+                    if (type.termType === "NamedNode" && type.value === mod_js_1.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 <${mod_js_1.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(mod_js_1.rdf.type);
+        if (!typeTerms) {
+            return [];
+        }
+        return typeTerms.reduce((acc, term) => {
+            if (term.value !== mod_js_1.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 (0, rdf_js_1.fromRdf)(term);
+        }
+        else {
+            throw new Error(`Unsupported term type to resolve: ${term.termType}`);
+        }
+    }
+}
+const decode = (graph, schema, context) => {
+    return Decoder.decode(graph, schema, context);
+};
+exports.decode = decode;

package/script/library/encoder.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode = void 0;
+const rdf_js_1 = require("./rdf.js");
+const mod_js_1 = require("./namespaces/mod.js");
+const encode = (node, schema, context, variableInitCounter = 0) => {
+    return Encoder.encode(node, schema, context, variableInitCounter);
+};
+exports.encode = encode;
+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 rdf_js_1.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(mod_js_1.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, (0, rdf_js_1.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"] ?? mod_js_1.xsd.string;
+            if (typeof val === "string" && this.context.language) {
+                if (propertyType === mod_js_1.xsd.string || propertyType === mod_js_1.rdf.langString) {
+                    this.push(nodeId, propertyId, (0, rdf_js_1.literal)(val, this.context.language));
+                    return;
+                }
+            }
+            const rdfValue = (0, rdf_js_1.toRdf)(val, {
+                datatype: this.df.namedNode(property["@type"] ?? mod_js_1.xsd.string),
+            });
+            this.push(nodeId, propertyId, rdfValue);
+        });
+    }
+}

package/script/library/engine.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateQuery = exports.quadsQuery = exports.bindingsQuery = exports.booleanQuery = void 0;
+const mod_js_1 = require("./comunica/mod.js");
+const rxjs_js_1 = require("./rxjs.js");
+const context_js_1 = require("./context.js");
+const rdf_js_1 = require("./rdf.js");
+const engine = new mod_js_1.QueryEngine();
+const booleanQuery = (query, context) => (0, rxjs_js_1.from)(engine.queryBoolean(query, (0, context_js_1.resolveContext)(context)));
+exports.booleanQuery = booleanQuery;
+const bindingsQuery = (query, context) => (0, rxjs_js_1.from)(engine.queryBindings(query, (0, context_js_1.resolveContext)(context))).pipe((0, rxjs_js_1.switchMap)((stream) => (0, rxjs_js_1.from)(stream.toArray())));
+exports.bindingsQuery = bindingsQuery;
+const quadsQuery = (query, context) => (0, rxjs_js_1.from)(engine.queryQuads(query, (0, context_js_1.resolveContext)(context))).pipe((0, rxjs_js_1.switchMap)((stream) => (0, rxjs_js_1.from)(stream.toArray())), (0, rxjs_js_1.map)((quads) => (0, rdf_js_1.quadsToGraph)(quads)));
+exports.quadsQuery = quadsQuery;
+const updateQuery = (query, context) => (0, rxjs_js_1.from)(engine.queryVoid(query, (0, context_js_1.resolveContext)(context)));
+exports.updateQuery = updateQuery;

package/script/library/namespaces/dcterms.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const namespace_js_1 = require("./namespace.js");
+exports.default = (0, namespace_js_1.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/script/library/namespaces/ldkit.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const namespace_js_1 = require("./namespace.js");
+exports.default = (0, namespace_js_1.createNamespace)({
+    iri: "http://ldkit/",
+    prefix: "ldkit:",
+    terms: ["Resource"],
+});

package/script/library/namespaces/mod.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNamespace = exports.xsd = exports.skos = exports.schema = exports.ldkit = exports.dcterms = exports.rdf = void 0;
+var rdf_js_1 = require("./rdf.js");
+Object.defineProperty(exports, "rdf", { enumerable: true, get: function () { return __importDefault(rdf_js_1).default; } });
+var dcterms_js_1 = require("./dcterms.js");
+Object.defineProperty(exports, "dcterms", { enumerable: true, get: function () { return __importDefault(dcterms_js_1).default; } });
+var ldkit_js_1 = require("./ldkit.js");
+Object.defineProperty(exports, "ldkit", { enumerable: true, get: function () { return __importDefault(ldkit_js_1).default; } });
+var schema_js_1 = require("./schema.js");
+Object.defineProperty(exports, "schema", { enumerable: true, get: function () { return __importDefault(schema_js_1).default; } });
+var skos_js_1 = require("./skos.js");
+Object.defineProperty(exports, "skos", { enumerable: true, get: function () { return __importDefault(skos_js_1).default; } });
+var xsd_js_1 = require("./xsd.js");
+Object.defineProperty(exports, "xsd", { enumerable: true, get: function () { return __importDefault(xsd_js_1).default; } });
+var namespace_js_1 = require("./namespace.js");
+Object.defineProperty(exports, "createNamespace", { enumerable: true, get: function () { return namespace_js_1.createNamespace; } });

package/script/library/namespaces/namespace.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNamespace = void 0;
+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"],
+});
+exports.createNamespace = createNamespace;

package/script/library/namespaces/rdf.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const namespace_js_1 = require("./namespace.js");
+exports.default = (0, namespace_js_1.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",
+    ],
+});