ldkit 0.0.1 → 0.0.4

package/esm/library/namespaces/skos.js

@@ -0,0 +1,39 @@
+import { createNamespace } from "./namespace.js";
+export default createNamespace({
+    iri: "http://www.w3.org/2004/02/skos/core#",
+    prefix: "skos:",
+    terms: [
+        "Collection",
+        "Concept",
+        "ConceptScheme",
+        "OrderedCollection",
+        "altLabel",
+        "broadMatch",
+        "broader",
+        "broaderTransitive",
+        "changeNote",
+        "closeMatch",
+        "definition",
+        "editorialNote",
+        "exactMatch",
+        "example",
+        "hasTopConcept",
+        "hiddenLabel",
+        "historyNote",
+        "inScheme",
+        "mappingRelation",
+        "member",
+        "memberList",
+        "narrowMatch",
+        "narrower",
+        "narrowerTransitive",
+        "notation",
+        "note",
+        "prefLabel",
+        "related",
+        "relatedMatch",
+        "scopeNote",
+        "semanticRelation",
+        "topConceptOf",
+    ],
+});

package/esm/library/namespaces/xsd.js

@@ -0,0 +1,57 @@
+import { createNamespace } from "./namespace.js";
+export default createNamespace({
+    iri: "http://www.w3.org/2001/XMLSchema#",
+    prefix: "xsd:",
+    terms: [
+        "ENTITIES",
+        "ENTITY",
+        "ID",
+        "IDREF",
+        "IDREFS",
+        "NCName",
+        "NMTOKEN",
+        "NMTOKENS",
+        "NOTATION",
+        "Name",
+        "QName",
+        "anyAtomicType",
+        "anySimpleType",
+        "anyType",
+        "anyURI",
+        "base64Binary",
+        "boolean",
+        "byte",
+        "date",
+        "dateTime",
+        "dateTimeStamp",
+        "dayTimeDuration",
+        "decimal",
+        "double",
+        "duration",
+        "float",
+        "gDay",
+        "gMonth",
+        "gMonthDay",
+        "gYear",
+        "gYearMonth",
+        "hexBinary",
+        "int",
+        "integer",
+        "language",
+        "long",
+        "negativeInteger",
+        "nonNegativeInteger",
+        "nonPositiveInteger",
+        "normalizedString",
+        "positiveInteger",
+        "short",
+        "string",
+        "time",
+        "token",
+        "unsignedByte",
+        "unsignedInt",
+        "unsignedLong",
+        "unsignedShort",
+        "yearMonthDuration",
+    ],
+});

package/esm/library/rdf.js

@@ -0,0 +1,19 @@
+export { fromRdf, toRdf } from "rdf-literal";
+import * as DataFactory from "rdf-data-factory";
+export { DataFactory } from "rdf-data-factory";
+export const namedNode = (value) => new DataFactory.NamedNode(value);
+export const blankNode = (value) => new DataFactory.BlankNode(value);
+export const literal = (value, languageOrDatatype) => new DataFactory.Literal(value, languageOrDatatype);
+export const quad = (subject, predicate, object, graph) => new DataFactory.Quad(subject, predicate, object, graph || DataFactory.DefaultGraph.INSTANCE);
+export const variable = (value) => new DataFactory.Variable(value);
+export const quadsToGraph = (quads) => {
+    const graph = new Map();
+    for (const quad of quads) {
+        const s = quad.subject.value;
+        const p = quad.predicate.value;
+        const predicateMap = graph.get(s) || graph.set(s, new Map()).get(s);
+        const termArray = predicateMap.get(p) || predicateMap.set(p, []).get(p);
+        termArray.push(quad.object);
+    }
+    return graph;
+};

package/esm/library/resource/mod.js

@@ -0,0 +1 @@
+export { createResource, Resource } from "./resource.js";

package/esm/library/resource/query_builder.js

@@ -0,0 +1,147 @@
+import { getSchemaProperties } from "../schema/mod.js";
+import { $, CONSTRUCT, SELECT, INSERT, DELETE } from "../sparql.js";
+import { variable, namedNode, quad } from "../rdf.js";
+import { rdf, ldkit } from "../namespaces/mod.js";
+import { encode } from "../encoder.js";
+import { QueryHelper } from "./query_helper.js";
+export class QueryBuilder {
+    constructor(schema, context) {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "schemaProperties", {
+            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, "deleteQuery", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (iris) => {
+                return DELETE `
+      ?s ?p ?o
+    `.WHERE `
+      ?s ?p ?o .
+      VALUES ?s { ${iris.map(namedNode)} }
+    `.build();
+            }
+        });
+        this.schema = schema;
+        this.schemaProperties = getSchemaProperties(this.schema);
+        this.context = context;
+    }
+    getResourceSignature() {
+        return quad(variable("iri"), namedNode(rdf.type), namedNode(ldkit.Resource));
+    }
+    getTypesSignature() {
+        return quad(variable("iri"), namedNode(rdf.type), variable("iri_type"));
+    }
+    entitiesToQuads(entities) {
+        const quadArrays = entities.map((entity) => encode(entity, this.schema, this.context));
+        return [].concat(...quadArrays);
+    }
+    getShape(includeOptional = false, wrapOptional = true, omitRootTypes = false) {
+        const mainVar = "iri";
+        const conditions = [];
+        const populateConditionsRecursive = (s, varPrefix) => {
+            const rdfType = s["@type"];
+            const properties = getSchemaProperties(s);
+            if (varPrefix !== "iri" || !omitRootTypes) {
+                rdfType.forEach((type) => {
+                    conditions.push(quad(variable(varPrefix), namedNode(rdf.type), namedNode(type)));
+                });
+            }
+            Object.keys(properties).forEach((prop, index) => {
+                const property = properties[prop];
+                const isOptional = property["@optional"];
+                if (!includeOptional && isOptional) {
+                    return;
+                }
+                if (wrapOptional && isOptional) {
+                    conditions.push($ `\nOPTIONAL {`);
+                }
+                conditions.push(quad(variable(varPrefix), namedNode(property["@id"]), variable(`${varPrefix}_${index}`)));
+                if (typeof property["@context"] === "object") {
+                    populateConditionsRecursive(property["@context"], `${varPrefix}_${index}`);
+                }
+                if (wrapOptional && isOptional) {
+                    conditions.push($ `\n}\n`);
+                }
+            });
+        };
+        populateConditionsRecursive(this.schema, mainVar);
+        return conditions;
+    }
+    countQuery() {
+        const quads = this.getShape();
+        return SELECT `(count(?iri) as ?count)`.WHERE `${quads}`.build();
+    }
+    getQuery(where, limit = 1000) {
+        const selectSubQuery = SELECT `
+      ${variable("iri")}
+    `.WHERE `
+      ${this.getShape(false, true)}
+      ${where}
+    `.LIMIT(limit);
+        const query = CONSTRUCT `
+      ${this.getResourceSignature()}
+      ${this.getTypesSignature()}
+      ${this.getShape(true, false, true)}
+    `.WHERE `
+      ${this.getTypesSignature()}
+      ${this.getShape(true, true, true)}
+      {
+        ${selectSubQuery}
+      }
+    `.build();
+        return query;
+    }
+    getByIrisQuery(iris) {
+        const query = CONSTRUCT `
+      ${this.getResourceSignature()}
+      ${this.getTypesSignature()}
+      ${this.getShape(true, false, true)}
+    `.WHERE `
+      ${this.getTypesSignature()}
+      ${this.getShape(true, true, true)}
+      VALUES ?iri {
+        ${iris.map(namedNode)}
+      }
+    `.build();
+        return query;
+    }
+    insertQuery(entities) {
+        const quads = this.entitiesToQuads(entities);
+        return this.insertDataQuery(quads);
+    }
+    insertDataQuery(quads) {
+        return INSERT.DATA `${quads}`.build();
+    }
+    deleteDataQuery(quads) {
+        return $ `DELETE DATA { ${quads} }`.toString();
+    }
+    updateQuery(entities) {
+        const deleteQuads = [];
+        const insertQuads = [];
+        const whereQuads = [];
+        entities.forEach((entity, index) => {
+            const helper = new QueryHelper(entity, this.schema, this.context, 1000 * index);
+            deleteQuads.push(...helper.getDeleteQuads());
+            insertQuads.push(...helper.getInsertQuads());
+            whereQuads.push(...helper.getWhereQuads());
+        });
+        return DELETE `${deleteQuads}`.INSERT `${insertQuads}`
+            .WHERE `${deleteQuads}`.build();
+    }
+}

package/esm/library/resource/query_helper.js

@@ -0,0 +1,102 @@
+import { encode } from "../encoder.js";
+export class QueryHelper {
+    constructor(entity, schema, context, variableInitCounter = 0) {
+        Object.defineProperty(this, "entity", {
+            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, "variableInitCounter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "quads", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "variableQuads", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.entity = entity;
+        this.schema = schema;
+        this.context = context;
+        this.variableInitCounter = variableInitCounter;
+    }
+    getQuads() {
+        if (!this.quads) {
+            this.quads = encode(this.entity, this.schema, this.context, this.variableInitCounter);
+        }
+        return this.quads;
+    }
+    getVariableQuads() {
+        if (!this.variableQuads) {
+            this.variableQuads = encode(this.getEntityWithReplacedVariables(), this.schema, this.context, this.variableInitCounter);
+        }
+        return this.variableQuads;
+    }
+    getDeleteQuads() {
+        return this.getVariableQuads().filter((quad) => quad.object.termType === "Variable");
+    }
+    getInsertQuads() {
+        return this.getQuads();
+    }
+    getWhereQuads() {
+        return this.getVariableQuads();
+    }
+    getEntityWithReplacedVariables() {
+        return this.replaceVariables(this.entity, this.schema);
+    }
+    replaceVariables(entity, schema) {
+        return Object.keys(entity).reduce((output, key) => {
+            const value = entity[key];
+            if (key === "$id") {
+                output.$id = value;
+                return output;
+            }
+            if (key === "$type") {
+                output.$type = value;
+                return output;
+            }
+            const property = schema[key];
+            if (!property) {
+                throw new Error("Unknown field '${key}' detected in entity");
+            }
+            if (!property["@context"]) {
+                output[key] = null;
+                return output;
+            }
+            if (property["@array"]) {
+                if (value.length === 0) {
+                    output[key] = null;
+                }
+                else {
+                    output[key] = value.map((subEntity) => this.replaceVariables(subEntity, property["@context"]));
+                }
+            }
+            else {
+                output[key] = this.replaceVariables(value, property["@context"]);
+            }
+            return output;
+        }, {});
+    }
+}

package/esm/library/resource/resource.js

@@ -0,0 +1,102 @@
+import { map, switchMap, tap, share, BehaviorSubject } from "../rxjs.js";
+import { bindingsQuery, quadsQuery, updateQuery } from "../engine.js";
+import { resolveContext } from "../context.js";
+import { expandSchema, } from "../schema/mod.js";
+import { decode } from "../decoder.js";
+import { QueryBuilder } from "./query_builder.js";
+export const createResource = (spec, context) => new Resource(spec, context);
+export class Resource {
+    constructor(schema, context) {
+        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, "queryBuilder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "$trigger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new BehaviorSubject(null)
+        });
+        this.schema = expandSchema(schema);
+        this.context = resolveContext(context);
+        this.queryBuilder = new QueryBuilder(this.schema, this.context);
+    }
+    decode(graph) {
+        return decode(graph, this.schema, this.context);
+    }
+    count() {
+        const q = this.queryBuilder.countQuery();
+        console.log(q);
+        return this.$trigger.pipe(switchMap(() => bindingsQuery(q, this.context)), map((bindings) => {
+            console.warn("BINDINGS", bindings);
+            return parseInt(bindings[0].get("count").value);
+        }));
+    }
+    //exists(entity: Identity) {}
+    query(sparqlConstructQuery) {
+        console.log(sparqlConstructQuery);
+        return quadsQuery(sparqlConstructQuery, this.context).pipe(map((graph) => {
+            return this.decode(graph);
+        }));
+    }
+    find(where, limit) {
+        const q = this.queryBuilder.getQuery(where, limit);
+        console.log(q);
+        return this.$trigger.pipe(switchMap(() => quadsQuery(q, this.context)), map((graph) => {
+            return this.decode(graph);
+        }));
+    }
+    findByIri(iri) {
+        return this.findByIris([iri]).pipe(map((result) => (result.length > 0 ? result[0] : undefined)));
+    }
+    findByIris(iris) {
+        const q = this.queryBuilder.getByIrisQuery(iris);
+        console.log(q);
+        return this.$trigger.pipe(switchMap(() => quadsQuery(q, this.context)), map((graph) => {
+            return this.decode(graph);
+        }));
+    }
+    updateQuery(query) {
+        console.log(query);
+        const result = updateQuery(query, this.context).pipe(tap(() => this.$trigger.next(null)), share());
+        result.subscribe();
+        return result;
+    }
+    insert(...entities) {
+        const q = this.queryBuilder.insertQuery(entities);
+        return this.updateQuery(q);
+    }
+    insertData(...quads) {
+        const q = this.queryBuilder.insertDataQuery(quads);
+        return this.updateQuery(q);
+    }
+    update(...entities) {
+        const q = this.queryBuilder.updateQuery(entities);
+        return this.updateQuery(q);
+    }
+    delete(...identities) {
+        const iris = identities.map((identity) => {
+            return typeof identity === "string" ? identity : identity.$id;
+        });
+        const q = this.queryBuilder.deleteQuery(iris);
+        return this.updateQuery(q);
+    }
+    deleteData(...quads) {
+        const q = this.queryBuilder.deleteDataQuery(quads);
+        return this.updateQuery(q);
+    }
+}

package/esm/library/resource/types.js

@@ -0,0 +1 @@
+export {};

package/esm/library/rxjs.js

@@ -0,0 +1,2 @@
+export { from, BehaviorSubject, } from "rxjs";
+export { map, switchMap, tap, share, } from "rxjs/operators";

package/esm/library/schema/data_types.js

@@ -0,0 +1,37 @@
+import { rdf, xsd } from "../namespaces/mod.js";
+const SupportedDataTypesPrototype = {
+    [xsd.dateTime]: new Date(),
+    [xsd.date]: new Date(),
+    [xsd.gDay]: new Date(),
+    [xsd.gMonthDay]: new Date(),
+    [xsd.gYear]: new Date(),
+    [xsd.gYearMonth]: new Date(),
+    [xsd.boolean]: true,
+    [xsd.double]: 0.0,
+    [xsd.decimal]: 0.0,
+    [xsd.float]: 0.0,
+    [xsd.integer]: 0,
+    [xsd.long]: 0,
+    [xsd.int]: 0,
+    [xsd.byte]: 0,
+    [xsd.short]: 0,
+    [xsd.negativeInteger]: 0,
+    [xsd.nonNegativeInteger]: 0,
+    [xsd.nonPositiveInteger]: 0,
+    [xsd.positiveInteger]: 0,
+    [xsd.unsignedByte]: 0,
+    [xsd.unsignedInt]: 0,
+    [xsd.unsignedLong]: 0,
+    [xsd.unsignedShort]: 0,
+    [xsd.string]: "",
+    [xsd.normalizedString]: "",
+    [xsd.anyURI]: "",
+    [xsd.base64Binary]: "",
+    [xsd.language]: "",
+    [xsd.Name]: "",
+    [xsd.NCName]: "",
+    [xsd.NMTOKEN]: "",
+    [xsd.token]: "",
+    [xsd.hexBinary]: "",
+    [rdf.langString]: "",
+};

package/esm/library/schema/interface.js

@@ -0,0 +1 @@
+export {};

package/esm/library/schema/mod.js

@@ -0,0 +1 @@
+export { expandSchema, getSchemaProperties } from "./utils.js";

package/esm/library/schema/schema.js

@@ -0,0 +1 @@
+export {};

package/esm/library/schema/utils.js

@@ -0,0 +1,58 @@
+import { xsd } from "../namespaces/mod.js";
+export const expandSchema = (schemaPrototype) => {
+    const expandArray = (stringOrStrings) => {
+        return Array.isArray(stringOrStrings) ? stringOrStrings : [stringOrStrings];
+    };
+    const expandSchemaProperty = (stringOrProperty) => {
+        if (typeof stringOrProperty === "string") {
+            return {
+                "@id": stringOrProperty,
+                "@type": xsd.string,
+            };
+        }
+        const property = stringOrProperty;
+        if (!property["@id"]) {
+            throw new Error(`Invalid schema, "@id" key for property missing`);
+        }
+        const validKeys = [
+            "@context",
+            "@id",
+            "@type",
+            "@array",
+            "@optional",
+            "@multilang",
+        ];
+        const baseProperty = {
+            "@id": "",
+        };
+        const expandedProperty = Object.keys(property).reduce((acc, key) => {
+            if (key === "@context") {
+                acc[key] = expandSchema(property[key]);
+            }
+            else if (validKeys.includes(key)) {
+                acc[key] = property[key];
+            }
+            return acc;
+        }, baseProperty);
+        if (!baseProperty["@type"] && !baseProperty["@context"]) {
+            baseProperty["@type"] = xsd.string;
+        }
+        return expandedProperty;
+    };
+    const baseSchema = {
+        "@type": [],
+    };
+    return Object.keys(schemaPrototype).reduce((acc, key) => {
+        if (key === "@type") {
+            acc[key] = expandArray(schemaPrototype[key]);
+        }
+        else {
+            acc[key] = expandSchemaProperty(schemaPrototype[key]);
+        }
+        return acc;
+    }, baseSchema);
+};
+export const getSchemaProperties = (schema) => {
+    const { "@type": _ommitedType, ...properties } = schema;
+    return properties;
+};

package/esm/library/sparql.js

@@ -0,0 +1,2 @@
+export { sparql as $, } from "@tpluscode/rdf-string";
+export { DELETE, INSERT, ASK, DESCRIBE, CONSTRUCT, SELECT, WITH, } from "@tpluscode/sparql-builder";

package/esm/mod.js

@@ -0,0 +1,3 @@
+export { createResource } from "./library/resource/mod.js";
+export { createNamespace } from "./library/namespaces/namespace.js";
+export { createDefaultContext, createContext } from "./library/context.js";

package/package.json

@@ -1,8 +1,9 @@
 {
-  "module": "./esm/npm.js",
-  "main": "./script/npm.js",
+  "module": "./esm/mod.js",
+  "main": "./script/mod.js",
+  "types": "./types/mod.d.ts",
   "name": "ldkit",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "description": "LDKit",
   "license": "MIT",
   "repository": {
@@ -14,11 +15,38 @@
   },
   "exports": {
     ".": {
-      "import": "./esm/npm.js",
-      "require": "./script/npm.js"
+      "import": "./esm/mod.js",
+      "require": "./script/mod.js",
+      "types": "./types/mod.d.ts"
+    },
+    "./namespaces": {
+      "import": "./esm/library/namespaces/mod.js",
+      "require": "./script/library/namespaces/mod.js",
+      "types": "./types/library/namespaces/mod.d.ts"
+    },
+    "./rdf": {
+      "import": "./esm/library/rdf.js",
+      "require": "./script/library/rdf.js",
+      "types": "./types/library/rdf.d.ts"
+    },
+    "./sparql": {
+      "import": "./esm/library/sparql.js",
+      "require": "./script/library/sparql.js",
+      "types": "./types/library/sparql.d.ts"
     }
   },
+  "dependencies": {
+    "@comunica/types": "2.4.0",
+    "@tpluscode/rdf-string": "0.2.26",
+    "@tpluscode/sparql-builder": "0.3.23",
+    "rdf-data-factory": "1.1.1",
+    "rdf-js": "4.0.2",
+    "rdf-literal": "1.3.0",
+    "rxjs": "7.5.6",
+    "@deno/shim-deno": "~0.9.0",
+    "undici": "^5.8.0"
+  },
   "devDependencies": {
     "@types/node": "16.11.37"
   }
-}
+}