ldkit 1.1.0 → 2.1.0

package/esm/library/lens/query_builder.js

@@ -1,25 +1,28 @@
-import { getSchemaProperties } from "../schema/mod.js";
+import { getSchemaProperties, } from "../schema/mod.js";
 import { CONSTRUCT, DELETE, INSERT, SELECT, sparql as $, } from "../sparql/mod.js";
 import { DataFactory } from "../rdf.js";
-import ldkit from "../namespaces/ldkit.js";
-import rdf from "../namespaces/rdf.js";
+import { ldkit } from "../../namespaces/ldkit.js";
+import { rdf } from "../../namespaces/rdf.js";
 import { encode } from "../encoder.js";
-import { QueryHelper } from "./query_helper.js";
+import { UpdateHelper } from "./update_helper.js";
+import { SearchHelper } from "./search_helper.js";
+var Flags;
+(function (Flags) {
+    Flags[Flags["None"] = 0] = "None";
+    Flags[Flags["ExcludeOptional"] = 1] = "ExcludeOptional";
+    Flags[Flags["UnwrapOptional"] = 2] = "UnwrapOptional";
+    Flags[Flags["IncludeTypes"] = 4] = "IncludeTypes";
+    Flags[Flags["IgnoreInverse"] = 8] = "IgnoreInverse";
+})(Flags || (Flags = {}));
 export class QueryBuilder {
-    constructor(schema, context) {
+    constructor(schema, options) {
         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", {
+        Object.defineProperty(this, "options", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -45,24 +48,32 @@ export class QueryBuilder {
             }
         });
         this.schema = schema;
-        this.schemaProperties = getSchemaProperties(this.schema);
-        this.context = context;
+        this.options = options;
         this.df = new DataFactory();
     }
     getResourceSignature() {
         return this.df.quad(this.df.variable("iri"), this.df.namedNode(rdf.type), this.df.namedNode(ldkit.Resource));
     }
-    getTypesSignature() {
-        return this.df.quad(this.df.variable("iri"), this.df.namedNode(rdf.type), this.df.variable("iri_type"));
-    }
     entitiesToQuads(entities) {
-        const quadArrays = entities.map((entity) => encode(entity, this.schema, this.context));
+        const quadArrays = entities.map((entity) => encode(entity, this.schema, this.options));
         return [].concat(...quadArrays);
     }
-    getShape(includeOptional = false, wrapOptional = true, omitRootTypes = false) {
+    getShape(flags, searchSchema) {
+        const includeOptional = (flags & Flags.ExcludeOptional) === 0;
+        const wrapOptional = (flags & Flags.UnwrapOptional) === 0;
+        const omitRootTypes = (flags & Flags.IncludeTypes) === 0;
+        const ignoreInverse = (flags & Flags.IgnoreInverse) === Flags.IgnoreInverse;
         const mainVar = "iri";
         const conditions = [];
-        const populateConditionsRecursive = (s, varPrefix) => {
+        const populateSearchConditions = (property, varName, search) => {
+            if (search === undefined) {
+                return;
+            }
+            const helper = new SearchHelper(property, varName, search);
+            helper.process();
+            conditions.push(helper.sparqlValues);
+        };
+        const populateConditionsRecursive = (s, varPrefix, search) => {
             const rdfType = s["@type"];
             const properties = getSchemaProperties(s);
             if (varPrefix !== "iri" || !omitRootTypes) {
@@ -73,59 +84,87 @@ export class QueryBuilder {
             Object.keys(properties).forEach((prop, index) => {
                 const property = properties[prop];
                 const isOptional = property["@optional"];
-                if (!includeOptional && isOptional) {
+                const propertySchema = search?.[prop];
+                if (!includeOptional && isOptional && propertySchema === undefined) {
                     return;
                 }
                 if (wrapOptional && isOptional) {
                     conditions.push($ `\nOPTIONAL {`);
                 }
-                conditions.push(this.df.quad(this.df.variable(varPrefix), this.df.namedNode(property["@id"]), this.df.variable(`${varPrefix}_${index}`)));
-                if (typeof property["@context"] === "object") {
-                    populateConditionsRecursive(property["@context"], `${varPrefix}_${index}`);
+                const isInverse = property["@inverse"];
+                if (ignoreInverse || !isInverse) {
+                    conditions.push(this.df.quad(this.df.variable(varPrefix), this.df.namedNode(property["@id"]), this.df.variable(`${varPrefix}_${index}`)));
+                    populateSearchConditions(property, `${varPrefix}_${index}`, propertySchema);
+                }
+                else {
+                    conditions.push(this.df.quad(this.df.variable(`${varPrefix}_${index}`), this.df.namedNode(property["@id"]), this.df.variable(varPrefix)));
+                }
+                if (typeof property["@schema"] === "object") {
+                    populateConditionsRecursive(property["@schema"], `${varPrefix}_${index}`, propertySchema);
                 }
                 if (wrapOptional && isOptional) {
                     conditions.push($ `\n}\n`);
                 }
             });
         };
-        populateConditionsRecursive(this.schema, mainVar);
+        populateConditionsRecursive(this.schema, mainVar, searchSchema);
         return conditions;
     }
-    countQuery() {
-        const quads = this.getShape();
-        return SELECT `(count(?iri) as ?count)`.WHERE `${quads}`.build();
+    countQuery(max) {
+        const quads = this.getShape(Flags.ExcludeOptional | Flags.IncludeTypes);
+        const innerQuery = max === undefined
+            ? quads
+            : SELECT `?iri`.WHERE `${quads}`.LIMIT(max);
+        return SELECT `(count(?iri) as ?count)`.WHERE `${innerQuery}`.build();
     }
-    getQuery(where, limit = 1000) {
-        const selectSubQuery = SELECT `
+    getQuery(where, limit, offset) {
+        const selectSubQuery = SELECT.DISTINCT `
       ${this.df.variable("iri")}
     `.WHERE `
-      ${this.getShape(false, true)}
+      ${this.getShape(Flags.ExcludeOptional | Flags.IncludeTypes)} 
       ${where}
-    `.LIMIT(limit).build();
+    `.LIMIT(limit).OFFSET(offset).build();
+        const query = CONSTRUCT `
+      ${this.getResourceSignature()}
+      ${this.getShape(Flags.UnwrapOptional | Flags.IgnoreInverse)}
+    `.WHERE `
+      {
+        ${selectSubQuery}
+      }
+      ${this.getShape(Flags.None)}
+    `.build();
+        return query;
+    }
+    getSearchQuery(where, limit, offset) {
+        if (where.$id) {
+            const ids = Array.isArray(where.$id) ? where.$id : [where.$id];
+            return this.getByIrisQuery(ids, where);
+        }
+        const selectSubQuery = SELECT.DISTINCT `
+      ${this.df.variable("iri")}
+    `.WHERE `
+      ${this.getShape(Flags.ExcludeOptional | Flags.IncludeTypes, where)} 
+    `.LIMIT(limit).OFFSET(offset).build();
         const query = CONSTRUCT `
       ${this.getResourceSignature()}
-      ${this.getTypesSignature()}
-      ${this.getShape(true, false, true)}
+      ${this.getShape(Flags.UnwrapOptional | Flags.IgnoreInverse)}
     `.WHERE `
-      ${this.getTypesSignature()}
-      ${this.getShape(true, true, true)}
       {
         ${selectSubQuery}
       }
+      ${this.getShape(Flags.None, where)}
     `.build();
         return query;
     }
-    getByIrisQuery(iris) {
+    getByIrisQuery(iris, where) {
         const query = CONSTRUCT `
       ${this.getResourceSignature()}
-      ${this.getTypesSignature()}
-      ${this.getShape(true, false, true)}
+      ${this.getShape(Flags.UnwrapOptional | Flags.IgnoreInverse)}
     `.WHERE `
-      ${this.getTypesSignature()}
-      ${this.getShape(true, true, true)}
       VALUES ?iri {
         ${iris.map(this.df.namedNode)}
       }
+      ${this.getShape(Flags.IncludeTypes, where)}
     `.build();
         return query;
     }
@@ -140,16 +179,11 @@ export class QueryBuilder {
         return DELETE.DATA `${quads}`.build();
     }
     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();
+        const helper = new UpdateHelper(this.schema, this.options);
+        for (const entity of entities) {
+            helper.process(entity);
+        }
+        return DELETE `${helper.deleteQuads}`.INSERT `${helper.insertQuads}`
+            .WHERE `${helper.whereQuads}`.build();
     }
 }

package/esm/library/lens/search_helper.js

@@ -0,0 +1,142 @@
+import { DataFactory } from "../rdf.js";
+import { sparql as $ } from "../sparql/mod.js";
+import { encodeValue } from "../encoder.js";
+import { xsd } from "../../namespaces/xsd.js";
+export class SearchHelper {
+    constructor(property, varName, searchSchema) {
+        Object.defineProperty(this, "property", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "propertyType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "varName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "searchSchema", {
+            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, "sparqlValues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.property = property;
+        this.propertyType = property["@type"] ? property["@type"] : xsd.string;
+        this.varName = varName;
+        this.searchSchema = this.isPlainObject(searchSchema)
+            ? searchSchema
+            : { $equals: searchSchema };
+    }
+    process() {
+        this.processOperators();
+        this.processStringFunctions();
+        this.processRegex();
+        this.processLangMatches();
+        this.processArrayFunctions();
+        this.processFilter();
+    }
+    processOperators() {
+        const map = {
+            $equals: "=",
+            $not: "!=",
+            $gt: ">",
+            $gte: ">=",
+            $lt: "<",
+            $lte: "<=",
+        };
+        for (const [key, operator] of Object.entries(map)) {
+            const value = this.searchSchema[key];
+            if (value === undefined) {
+                continue;
+            }
+            this.addFilter($ `${this.df.variable(this.varName)} ${operator} ${this.encode(value)}`);
+        }
+    }
+    processStringFunctions() {
+        const map = {
+            $contains: "CONTAINS",
+            $strStarts: "STRSTARTS",
+            $strEnds: "STRENDS",
+        };
+        for (const [key, func] of Object.entries(map)) {
+            const value = this.searchSchema[key];
+            if (value === undefined) {
+                continue;
+            }
+            this.addFilter($ `${func}(${this.df.variable(this.varName)}, ${this.encode(value)})`);
+        }
+    }
+    processRegex() {
+        const value = this.searchSchema.$regex;
+        if (value === undefined) {
+            return;
+        }
+        this.addFilter($ `REGEX(${this.df.variable(this.varName)}, "${value}")`);
+    }
+    processLangMatches() {
+        const value = this.searchSchema.$langMatches;
+        if (value === undefined) {
+            return;
+        }
+        this.addFilter($ `LANGMATCHES(LANG(${this.df.variable(this.varName)}), "${value}")`);
+    }
+    processArrayFunctions() {
+        const map = {
+            $in: "IN",
+            $notIn: "NOT IN",
+        };
+        for (const [key, func] of Object.entries(map)) {
+            const value = this.searchSchema[key];
+            if (value === undefined) {
+                continue;
+            }
+            const values = value.map((v) => $ `${this.encode(v)}`);
+            this.addFilter($ `${this.df.variable(this.varName)} ${func} (${values.join(", ")})`);
+        }
+    }
+    processFilter() {
+        const value = this.searchSchema.$filter;
+        if (value === undefined) {
+            return;
+        }
+        const stringified = $ `${value}`;
+        this.addFilter(stringified.replace("?value", `?${this.varName}`));
+    }
+    addFilter(filter) {
+        this.sparqlValues.push($ `FILTER (${filter}) .`);
+    }
+    encode(value) {
+        return encodeValue(value, this.propertyType, this.df);
+    }
+    isPlainObject(value) {
+        if (typeof value !== "object" || value === null) {
+            return false;
+        }
+        const prototype = Object.getPrototypeOf(value);
+        return (prototype === null || prototype === Object.prototype ||
+            Object.getPrototypeOf(prototype) === null) &&
+            !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+    }
+}

package/esm/library/lens/update_helper.js

@@ -0,0 +1,157 @@
+import { OPTIONAL } from "../sparql/mod.js";
+import { getSchemaProperties, } from "../schema/mod.js";
+import { encode } from "../encoder.js";
+export class UpdateHelper {
+    constructor(schema, options, variableInitCounter = 0) {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "properties", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "variableCounter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "deleteQuads", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "insertQuads", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "whereQuads", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.schema = schema;
+        this.properties = getSchemaProperties(schema);
+        this.options = options;
+        this.variableCounter = variableInitCounter;
+    }
+    process(entity) {
+        for (const name in this.properties) {
+            this.processProperty(entity, name, this.properties[name]);
+        }
+    }
+    processProperty(entity, propertyName, property) {
+        this.variableCounter++;
+        const value = entity[propertyName];
+        if (value === undefined) {
+            return;
+        }
+        if (property["@array"]) {
+            this.processArrayProperty(entity, propertyName, value);
+        }
+        else {
+            this.processSingleProperty(entity, propertyName, value, property);
+        }
+    }
+    processSingleProperty(entity, propertyName, propertyValue, property) {
+        const deletePattern = {
+            $id: entity.$id,
+            [propertyName]: null,
+        };
+        const quadsToDelete = this.encode(deletePattern);
+        this.deleteQuads.push(...quadsToDelete);
+        if (property["@optional"]) {
+            this.whereQuads.push(OPTIONAL `${quadsToDelete}`);
+        }
+        else {
+            this.whereQuads.push(...quadsToDelete);
+        }
+        if (property["@optional"] && propertyValue === null) {
+            // The intention was to delete a value of an optional property, nothing to insert
+            return;
+        }
+        const insertPattern = {
+            $id: entity.$id,
+            [propertyName]: propertyValue,
+        };
+        const quadsToInsert = this.encode(insertPattern);
+        this.insertQuads.push(...quadsToInsert);
+    }
+    processArrayProperty(entity, propertyName, propertyValue) {
+        const config = this.parseArrayUpdateConfig(propertyValue);
+        if (config.$set) {
+            this.processArraySet(entity, propertyName, config.$set);
+        }
+        else {
+            this.processArrayAddRemove(entity, propertyName, config.$add, config.$remove);
+        }
+    }
+    processArraySet(entity, propertyName, propertyValue) {
+        const deletePattern = {
+            $id: entity.$id,
+            [propertyName]: null,
+        };
+        const quadsToDelete = this.encode(deletePattern);
+        this.deleteQuads.push(...quadsToDelete);
+        this.whereQuads.push(...quadsToDelete);
+        const insertPattern = {
+            $id: entity.$id,
+            [propertyName]: propertyValue,
+        };
+        const quadsToInsert = this.encode(insertPattern);
+        this.insertQuads.push(...quadsToInsert);
+    }
+    processArrayAddRemove(entity, propertyName, $add, $remove) {
+        if ($remove) {
+            const deletePattern = {
+                $id: entity.$id,
+                [propertyName]: $remove,
+            };
+            const quadsToDelete = this.encode(deletePattern);
+            this.deleteQuads.push(...quadsToDelete);
+        }
+        if ($add) {
+            const insertPattern = {
+                $id: entity.$id,
+                [propertyName]: $add,
+            };
+            const quadsToInsert = this.encode(insertPattern);
+            this.insertQuads.push(...quadsToInsert);
+        }
+    }
+    parseArrayUpdateConfig(config) {
+        if (Array.isArray(config)) {
+            return { $set: config, $add: undefined, $remove: undefined };
+        }
+        if (config == null || typeof config !== "object") {
+            throw new Error("Invalid array update query, expected an array, or an object with $add, $set, or $remove properties");
+        }
+        const { $add, $set, $remove } = config;
+        switch (true) {
+            case Array.isArray($set) && $add === undefined && $remove === undefined:
+            case $set === undefined && Array.isArray($add) && $remove === undefined:
+            case $set === undefined && $add === undefined && Array.isArray($remove):
+            case $set === undefined && Array.isArray($add) && Array.isArray($remove):
+                return { $add, $set, $remove };
+        }
+        throw new Error("Invalid array update query, expected an array, or an object with $add, $set, or $remove properties");
+    }
+    encode(entity) {
+        return encode(entity, this.schema, this.options, false, this.variableCounter);
+    }
+}

package/esm/library/namespace.js

@@ -0,0 +1,36 @@
+/**
+ * Creates a strongly typed container for Linked Data vocabulary to provide
+ * type safe access to all vocabulary terms as well as IDE autocompletion.
+ *
+ * @example
+ * ```typescript
+ * import { createNamespace } from "ldkit";
+ *
+ * const onto = createNamespace(
+ *   {
+ *     iri: "http://www.example.com/ontology#",
+ *     prefix: "onto:",
+ *     terms: [
+ *       "object",
+ *       "predicate",
+ *       "subject",
+ *     ],
+ *   } as const,
+ * );
+ *
+ * console.log(onto.subject); // prints http://www.example.com/ontology#subject
+ * console.log(onto.unknown); // TypeScript error! This term does not exist
+ * ```
+ *
+ * @param namespaceSpec Specification of the namespace
+ * @returns
+ */
+export function createNamespace(namespaceSpec) {
+    return Object.assign(namespaceSpec.terms.reduce((acc, term) => {
+        acc[term] = `${namespaceSpec.iri}${term}`;
+        return acc;
+    }, {}), {
+        $prefix: namespaceSpec["prefix"],
+        $iri: namespaceSpec["iri"],
+    });
+}

package/esm/library/options.js

@@ -0,0 +1,50 @@
+import { QueryEngine, } from "./engine/mod.js";
+const defaultOptions = {
+    engine: new QueryEngine(),
+    take: 1000,
+    logQuery: () => { },
+};
+let globalOptions = {};
+/**
+ * Sets global configuration {@link Options} for LDkit that will be used
+ * by default in all queries, unless overridden in {@link Lens}.
+ *
+ * LDkit-specific options are:
+ * - `engine` - a query engine to use for querying data sources
+ * - `language` - a preferred language for literals
+ * - `take` - a default number of results to take (limit of SELECT queries)
+ * - `logQuery` - a function that will be called for each SPARQL query
+ *
+ * Default values for these options are:
+ * ```typescript
+ * const defaultOptions = {
+ *   engine: new QueryEngine(),
+ *   take: 1000,
+ *   logQuery: () => {},
+ * };
+ * ```
+ * The default configuration uses built-in {@link QueryEngine}. Language is not set by default.
+ *
+ * @param options LDkit options and query engine context
+ */
+export function setGlobalOptions(options) {
+    globalOptions = options;
+}
+export function resolveOptions(options = {}) {
+    return {
+        ...defaultOptions,
+        ...globalOptions,
+        ...options,
+    };
+}
+export function resolveQueryContext(options) {
+    const { engine: _engine, language: _language, take: _take, ...context } = options;
+    if (context.source !== undefined && context.sources === undefined) {
+        context.sources = [context.source];
+        delete context.source;
+    }
+    if (context.sources === undefined) {
+        throw new Error("No data source defined in Options");
+    }
+    return context;
+}

package/esm/library/schema/data_types.js

@@ -1,38 +1,3 @@
-import xsd from "../namespaces/xsd.js";
-import rdf from "../namespaces/rdf.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]: "",
-};
+import { xsd } from "../../namespaces/xsd.js";
+import { rdf } from "../../namespaces/rdf.js";
+import { ldkit } from "../../namespaces/ldkit.js";

package/esm/library/schema/search.js

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