ldkit 0.0.1 → 0.0.4

package/script/library/namespaces/skos.js

@@ -0,0 +1,41 @@
+"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/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/script/library/namespaces/xsd.js

@@ -0,0 +1,59 @@
+"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/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/script/library/rdf.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quadsToGraph = exports.variable = exports.quad = exports.literal = exports.blankNode = exports.namedNode = exports.DataFactory = exports.toRdf = exports.fromRdf = void 0;
+var rdf_literal_1 = require("rdf-literal");
+Object.defineProperty(exports, "fromRdf", { enumerable: true, get: function () { return rdf_literal_1.fromRdf; } });
+Object.defineProperty(exports, "toRdf", { enumerable: true, get: function () { return rdf_literal_1.toRdf; } });
+const DataFactory = __importStar(require("rdf-data-factory"));
+var rdf_data_factory_1 = require("rdf-data-factory");
+Object.defineProperty(exports, "DataFactory", { enumerable: true, get: function () { return rdf_data_factory_1.DataFactory; } });
+const namedNode = (value) => new DataFactory.NamedNode(value);
+exports.namedNode = namedNode;
+const blankNode = (value) => new DataFactory.BlankNode(value);
+exports.blankNode = blankNode;
+const literal = (value, languageOrDatatype) => new DataFactory.Literal(value, languageOrDatatype);
+exports.literal = literal;
+const quad = (subject, predicate, object, graph) => new DataFactory.Quad(subject, predicate, object, graph || DataFactory.DefaultGraph.INSTANCE);
+exports.quad = quad;
+const variable = (value) => new DataFactory.Variable(value);
+exports.variable = variable;
+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;
+};
+exports.quadsToGraph = quadsToGraph;

package/script/library/resource/mod.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resource = exports.createResource = void 0;
+var resource_js_1 = require("./resource.js");
+Object.defineProperty(exports, "createResource", { enumerable: true, get: function () { return resource_js_1.createResource; } });
+Object.defineProperty(exports, "Resource", { enumerable: true, get: function () { return resource_js_1.Resource; } });

package/script/library/resource/query_builder.js

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

package/script/library/resource/query_helper.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryHelper = void 0;
+const encoder_js_1 = require("../encoder.js");
+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 = (0, encoder_js_1.encode)(this.entity, this.schema, this.context, this.variableInitCounter);
+        }
+        return this.quads;
+    }
+    getVariableQuads() {
+        if (!this.variableQuads) {
+            this.variableQuads = (0, encoder_js_1.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;
+        }, {});
+    }
+}
+exports.QueryHelper = QueryHelper;

package/script/library/resource/resource.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resource = exports.createResource = void 0;
+const rxjs_js_1 = require("../rxjs.js");
+const engine_js_1 = require("../engine.js");
+const context_js_1 = require("../context.js");
+const mod_js_1 = require("../schema/mod.js");
+const decoder_js_1 = require("../decoder.js");
+const query_builder_js_1 = require("./query_builder.js");
+const createResource = (spec, context) => new Resource(spec, context);
+exports.createResource = createResource;
+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 rxjs_js_1.BehaviorSubject(null)
+        });
+        this.schema = (0, mod_js_1.expandSchema)(schema);
+        this.context = (0, context_js_1.resolveContext)(context);
+        this.queryBuilder = new query_builder_js_1.QueryBuilder(this.schema, this.context);
+    }
+    decode(graph) {
+        return (0, decoder_js_1.decode)(graph, this.schema, this.context);
+    }
+    count() {
+        const q = this.queryBuilder.countQuery();
+        console.log(q);
+        return this.$trigger.pipe((0, rxjs_js_1.switchMap)(() => (0, engine_js_1.bindingsQuery)(q, this.context)), (0, rxjs_js_1.map)((bindings) => {
+            console.warn("BINDINGS", bindings);
+            return parseInt(bindings[0].get("count").value);
+        }));
+    }
+    //exists(entity: Identity) {}
+    query(sparqlConstructQuery) {
+        console.log(sparqlConstructQuery);
+        return (0, engine_js_1.quadsQuery)(sparqlConstructQuery, this.context).pipe((0, rxjs_js_1.map)((graph) => {
+            return this.decode(graph);
+        }));
+    }
+    find(where, limit) {
+        const q = this.queryBuilder.getQuery(where, limit);
+        console.log(q);
+        return this.$trigger.pipe((0, rxjs_js_1.switchMap)(() => (0, engine_js_1.quadsQuery)(q, this.context)), (0, rxjs_js_1.map)((graph) => {
+            return this.decode(graph);
+        }));
+    }
+    findByIri(iri) {
+        return this.findByIris([iri]).pipe((0, rxjs_js_1.map)((result) => (result.length > 0 ? result[0] : undefined)));
+    }
+    findByIris(iris) {
+        const q = this.queryBuilder.getByIrisQuery(iris);
+        console.log(q);
+        return this.$trigger.pipe((0, rxjs_js_1.switchMap)(() => (0, engine_js_1.quadsQuery)(q, this.context)), (0, rxjs_js_1.map)((graph) => {
+            return this.decode(graph);
+        }));
+    }
+    updateQuery(query) {
+        console.log(query);
+        const result = (0, engine_js_1.updateQuery)(query, this.context).pipe((0, rxjs_js_1.tap)(() => this.$trigger.next(null)), (0, rxjs_js_1.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);
+    }
+}
+exports.Resource = Resource;

package/script/{npm.js → library/resource/types.js}

@@ -1,4 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ldkit = void 0;
-exports.ldkit = true;

package/script/library/rxjs.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.share = exports.tap = exports.switchMap = exports.map = exports.BehaviorSubject = exports.from = void 0;
+var rxjs_1 = require("rxjs");
+Object.defineProperty(exports, "from", { enumerable: true, get: function () { return rxjs_1.from; } });
+Object.defineProperty(exports, "BehaviorSubject", { enumerable: true, get: function () { return rxjs_1.BehaviorSubject; } });
+var operators_1 = require("rxjs/operators");
+Object.defineProperty(exports, "map", { enumerable: true, get: function () { return operators_1.map; } });
+Object.defineProperty(exports, "switchMap", { enumerable: true, get: function () { return operators_1.switchMap; } });
+Object.defineProperty(exports, "tap", { enumerable: true, get: function () { return operators_1.tap; } });
+Object.defineProperty(exports, "share", { enumerable: true, get: function () { return operators_1.share; } });

package/script/library/schema/data_types.js

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

package/script/library/schema/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/library/schema/mod.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaProperties = exports.expandSchema = void 0;
+var utils_js_1 = require("./utils.js");
+Object.defineProperty(exports, "expandSchema", { enumerable: true, get: function () { return utils_js_1.expandSchema; } });
+Object.defineProperty(exports, "getSchemaProperties", { enumerable: true, get: function () { return utils_js_1.getSchemaProperties; } });

package/script/library/schema/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/library/schema/utils.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaProperties = exports.expandSchema = void 0;
+const mod_js_1 = require("../namespaces/mod.js");
+const expandSchema = (schemaPrototype) => {
+    const expandArray = (stringOrStrings) => {
+        return Array.isArray(stringOrStrings) ? stringOrStrings : [stringOrStrings];
+    };
+    const expandSchemaProperty = (stringOrProperty) => {
+        if (typeof stringOrProperty === "string") {
+            return {
+                "@id": stringOrProperty,
+                "@type": mod_js_1.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] = (0, exports.expandSchema)(property[key]);
+            }
+            else if (validKeys.includes(key)) {
+                acc[key] = property[key];
+            }
+            return acc;
+        }, baseProperty);
+        if (!baseProperty["@type"] && !baseProperty["@context"]) {
+            baseProperty["@type"] = mod_js_1.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);
+};
+exports.expandSchema = expandSchema;
+const getSchemaProperties = (schema) => {
+    const { "@type": _ommitedType, ...properties } = schema;
+    return properties;
+};
+exports.getSchemaProperties = getSchemaProperties;

package/script/library/sparql.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WITH = exports.SELECT = exports.CONSTRUCT = exports.DESCRIBE = exports.ASK = exports.INSERT = exports.DELETE = exports.$ = void 0;
+var rdf_string_1 = require("@tpluscode/rdf-string");
+Object.defineProperty(exports, "$", { enumerable: true, get: function () { return rdf_string_1.sparql; } });
+var sparql_builder_1 = require("@tpluscode/sparql-builder");
+Object.defineProperty(exports, "DELETE", { enumerable: true, get: function () { return sparql_builder_1.DELETE; } });
+Object.defineProperty(exports, "INSERT", { enumerable: true, get: function () { return sparql_builder_1.INSERT; } });
+Object.defineProperty(exports, "ASK", { enumerable: true, get: function () { return sparql_builder_1.ASK; } });
+Object.defineProperty(exports, "DESCRIBE", { enumerable: true, get: function () { return sparql_builder_1.DESCRIBE; } });
+Object.defineProperty(exports, "CONSTRUCT", { enumerable: true, get: function () { return sparql_builder_1.CONSTRUCT; } });
+Object.defineProperty(exports, "SELECT", { enumerable: true, get: function () { return sparql_builder_1.SELECT; } });
+Object.defineProperty(exports, "WITH", { enumerable: true, get: function () { return sparql_builder_1.WITH; } });