ldkit 0.6.5 → 0.8.0

package/script/library/sparql/sparql_shared_builders.js

@@ -1,47 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.build = exports.createNamedNodeBuilder = exports.createNumericBuilder = exports.createTemplateBuilder = void 0;
+exports.SparqlBuilder = exports.parentheses = exports.braces = void 0;
 const rdf_js_1 = require("../rdf.js");
 const sparql_tag_js_1 = require("./sparql_tag.js");
-const createContext = (self, current, builders) => {
-    const previousQuery = self?.$partialQuery || "";
-    const context = { $partialQuery: previousQuery + current };
-    return Object.keys(builders).reduce((acc, key) => {
-        acc[key] = builders[key].bind(context);
-        return acc;
-    }, {});
-};
-const createTemplateBuilder = (wrap, builders) => {
-    return function (strings, ...values) {
-        const self = this;
-        const inner = (0, sparql_tag_js_1.sparql)(strings, ...values);
-        const current = wrap(inner);
-        return createContext(self, current, builders);
-    };
-};
-exports.createTemplateBuilder = createTemplateBuilder;
-const createNumericBuilder = (wrap, builders) => {
-    return function (number) {
-        const self = this;
-        const current = wrap(number);
-        return createContext(self, current, builders);
-    };
-};
-exports.createNumericBuilder = createNumericBuilder;
-const df = new rdf_js_1.DataFactory();
-const createNamedNodeBuilder = (wrap, builders) => {
-    return function (stringOrNamedNode) {
-        const self = this;
+const braces = (keyword, value) => `${keyword} {\n${value}\n}\n`;
+exports.braces = braces;
+const parentheses = (keyword, value) => `${keyword} (${value})\n`;
+exports.parentheses = parentheses;
+const none = (keyword, value) => `${keyword} ${value}\n`;
+class SparqlBuilder {
+    constructor() {
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        });
+        Object.defineProperty(this, "dataFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new rdf_js_1.DataFactory()
+        });
+    }
+    build() {
+        return this.value;
+    }
+    sparql(strings, ...values) {
+        return !values || values.length < 1
+            ? (0, sparql_tag_js_1.sparql)(strings)
+            : (0, sparql_tag_js_1.sparql)(strings, ...values);
+    }
+    template(strings, values, keyword, wrap = none) {
+        const inputSparql = this.sparql(strings, ...values);
+        this.value += wrap(keyword, inputSparql);
+        return this;
+    }
+    namedNode(stringOrNamedNode, keyword, wrap = none) {
         const namedNode = typeof stringOrNamedNode === "string"
-            ? df.namedNode(stringOrNamedNode)
+            ? this.dataFactory.namedNode(stringOrNamedNode)
             : stringOrNamedNode;
-        const inner = (0, sparql_tag_js_1.sparql) `${namedNode}`;
-        const current = wrap(inner);
-        return createContext(self, current, builders);
-    };
-};
-exports.createNamedNodeBuilder = createNamedNodeBuilder;
-const build = function () {
-    return this?.$partialQuery || "";
-};
-exports.build = build;
+        const inputSparql = this.sparql `${namedNode}`;
+        this.value += wrap(keyword, inputSparql);
+        return this;
+    }
+    number(number, keyword, wrap = none) {
+        this.value += wrap(keyword, number.toString());
+        return this;
+    }
+}
+exports.SparqlBuilder = SparqlBuilder;

package/script/library/sparql/sparql_update_builders.js

@@ -2,17 +2,37 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WITH = exports.DELETE = exports.INSERT = void 0;
 const sparql_shared_builders_js_1 = require("./sparql_shared_builders.js");
-const WHERE = (0, sparql_shared_builders_js_1.createTemplateBuilder)((value) => `WHERE {\n${value}\n}\n`, { build: sparql_shared_builders_js_1.build });
-const USING_NAMED = (0, sparql_shared_builders_js_1.createNamedNodeBuilder)((value) => `USING NAMED ${value}\n`, { WHERE });
-const USING = (0, sparql_shared_builders_js_1.createNamedNodeBuilder)((value) => `USING ${value}\n`, { USING_NAMED, WHERE });
-const _INSERT = (0, sparql_shared_builders_js_1.createTemplateBuilder)((value) => `INSERT {\n${value}\n}\n`, { USING, USING_NAMED, WHERE });
-const _INSERT_DATA = (0, sparql_shared_builders_js_1.createTemplateBuilder)((value) => `INSERT DATA {\n${value}\n}\n`, { build: sparql_shared_builders_js_1.build });
-exports.INSERT = Object.assign(_INSERT, {
-    DATA: _INSERT_DATA,
+class SparqlUpdateBuilder extends sparql_shared_builders_js_1.SparqlBuilder {
+    WHERE(strings, ...values) {
+        return this.template(strings, values, "WHERE", sparql_shared_builders_js_1.braces);
+    }
+    USING_NAMED(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "USING NAMED");
+    }
+    USING(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "USING");
+    }
+    INSERT(strings, ...values) {
+        return this.template(strings, values, "INSERT", sparql_shared_builders_js_1.braces);
+    }
+    INSERT_DATA(strings, ...values) {
+        return this.template(strings, values, "INSERT DATA", sparql_shared_builders_js_1.braces);
+    }
+    DELETE(strings, ...values) {
+        return this.template(strings, values, "DELETE", sparql_shared_builders_js_1.braces);
+    }
+    DELETE_DATA(strings, ...values) {
+        return this.template(strings, values, "DELETE DATA", sparql_shared_builders_js_1.braces);
+    }
+    WITH(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "WITH");
+    }
+}
+exports.INSERT = Object.assign((strings, ...values) => new SparqlUpdateBuilder().INSERT(strings, ...values), {
+    DATA: (strings, ...values) => new SparqlUpdateBuilder().INSERT_DATA(strings, ...values),
 });
-const _DELETE = (0, sparql_shared_builders_js_1.createTemplateBuilder)((value) => `DELETE {\n${value}\n}\n`, { INSERT: _INSERT, USING, USING_NAMED, WHERE });
-const _DELETE_DATA = (0, sparql_shared_builders_js_1.createTemplateBuilder)((value) => `DELETE DATA {\n${value}\n}\n`, { build: sparql_shared_builders_js_1.build });
-exports.DELETE = Object.assign(_DELETE, {
-    DATA: _DELETE_DATA,
+exports.DELETE = Object.assign((strings, ...values) => new SparqlUpdateBuilder().DELETE(strings, ...values), {
+    DATA: (strings, ...values) => new SparqlUpdateBuilder().DELETE_DATA(strings, ...values),
 });
-exports.WITH = (0, sparql_shared_builders_js_1.createNamedNodeBuilder)((value) => `WITH ${value}\n`, { build: sparql_shared_builders_js_1.build, INSERT: _INSERT, DELETE: _DELETE });
+const WITH = (stringOrNamedNode) => new SparqlUpdateBuilder().WITH(stringOrNamedNode);
+exports.WITH = WITH;

package/script/mod.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNamespace = exports.createResource = exports.setDefaultEngine = exports.setDefaultContext = void 0;
+exports.createNamespace = exports.createResource = exports.createLens = exports.setDefaultEngine = exports.setDefaultContext = void 0;
 var global_js_1 = require("./library/global.js");
 Object.defineProperty(exports, "setDefaultContext", { enumerable: true, get: function () { return global_js_1.setDefaultContext; } });
 Object.defineProperty(exports, "setDefaultEngine", { enumerable: true, get: function () { return global_js_1.setDefaultEngine; } });
-var mod_js_1 = require("./library/resource/mod.js");
+var mod_js_1 = require("./library/lens/mod.js");
+Object.defineProperty(exports, "createLens", { enumerable: true, get: function () { return mod_js_1.createLens; } });
 Object.defineProperty(exports, "createResource", { enumerable: true, get: function () { return mod_js_1.createResource; } });
 var namespace_js_1 = require("./library/namespaces/namespace.js");
 Object.defineProperty(exports, "createNamespace", { enumerable: true, get: function () { return namespace_js_1.createNamespace; } });

package/types/library/asynciterator.d.ts

@@ -1,10 +1,10 @@
 import { AsyncIterator } from "asynciterator";
 export { ArrayIterator, type AsyncIterator, MappingIterator, } from "asynciterator";
-declare type TreeNode<T> = {
+type TreeNode<T> = {
     [property: string]: T[] | TreeNode<T>;
 };
-export declare type Tree<T> = T[] | TreeNode<T>;
-declare type Subtree<T> = {
+export type Tree<T> = T[] | TreeNode<T>;
+type Subtree<T> = {
     type: "node";
     tree: TreeNode<T>;
     parent?: Subtree<T>;

package/types/library/decoder.d.ts

@@ -1,5 +1,5 @@
 import { type Context, Graph } from "./rdf.js";
 import type { Schema } from "./schema/mod.js";
-declare type DecodedNode = Record<string, unknown>;
+type DecodedNode = Record<string, unknown>;
 export declare const decode: (graph: Graph, schema: Schema, context: Context) => DecodedNode[];
 export {};

package/types/library/encoder.d.ts

@@ -1,5 +1,5 @@
 import { type Context, type RDF } from "./rdf.js";
 import type { Schema } from "./schema/mod.js";
-declare type DecodedNode = Record<string, unknown>;
+type DecodedNode = Record<string, unknown>;
 export declare const encode: (node: DecodedNode, schema: Schema, context: Context, variableInitCounter?: number) => RDF.Quad[];
 export {};

package/types/library/engine/query_engine.d.ts

@@ -1,5 +1,5 @@
 import { type Context, type IQueryEngine, type RDF, RDFJSON } from "../rdf.js";
-declare type QueryResponseFormat = {
+type QueryResponseFormat = {
     "application/sparql-results+json": RDFJSON.SparqlResultsJsonFormat;
     "application/rdf+json": RDFJSON.RdfJsonFormat;
 };

package/types/library/{resource/resource.d.ts → lens/lens.d.ts}

@@ -1,8 +1,23 @@
 import type { Context, IQueryEngine, Iri, RDF } from "../rdf.js";
 import { type SchemaInterface, type SchemaInterfaceIdentity, type SchemaPrototype } from "../schema/mod.js";
 import type { Entity } from "./types.js";
-export declare const createResource: <T extends SchemaPrototype>(spec: T, context?: Context, engine?: IQueryEngine) => Resource<T, SchemaInterface<T>>;
-export declare class Resource<S extends SchemaPrototype, I = SchemaInterface<S>> {
+/**
+ * Lens lets you query and update RDF data via data schema using TypeScript native data types.
+ *
+ * https://ldkit.io/docs/components/lens
+ *
+ * @param schema data schema which extends `SchemaPrototype`
+ * @param context optional `Context` - contains LDkit and query engine configuration
+ * @param engine optional Query Engine
+ * @returns Lens instance
+ */
+export declare const createLens: <T extends SchemaPrototype>(schema: T, context?: Context, engine?: IQueryEngine) => Lens<T, SchemaInterface<T>>;
+/**
+ * @deprecated
+ * Use `createLens` instead
+ */
+export declare const createResource: <T extends SchemaPrototype>(schema: T, context?: Context, engine?: IQueryEngine) => Lens<T, SchemaInterface<T>>;
+export declare class Lens<S extends SchemaPrototype, I = SchemaInterface<S>> {
     private readonly schema;
     private readonly context;
     private readonly engine;

package/types/library/lens/mod.d.ts

@@ -0,0 +1 @@
+export { createLens, createResource, type Lens } from "./lens.js";

package/types/library/lens/types.d.ts

@@ -0,0 +1,5 @@
+import type { SchemaInterfaceIdentity } from "../schema/mod.js";
+export type Entity<T extends unknown = Record<string, unknown>> = DeepPartial<T> & SchemaInterfaceIdentity;
+export type DeepPartial<T> = T extends Record<string, unknown> ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;

package/types/library/namespaces/namespace.d.ts

@@ -1,11 +1,11 @@
-declare type NamespacePrototype = {
+type NamespacePrototype = {
     iri: string;
     prefix: string;
     terms: readonly string[];
 };
-declare type NamespacePrefix<Namespace extends NamespacePrototype> = Namespace["prefix"];
-declare type NamespaceIri<Namespace extends NamespacePrototype> = Namespace["iri"];
-declare type NamespaceObject<Namespace extends NamespacePrototype> = {
+type NamespacePrefix<Namespace extends NamespacePrototype> = Namespace["prefix"];
+type NamespaceIri<Namespace extends NamespacePrototype> = Namespace["iri"];
+type NamespaceObject<Namespace extends NamespacePrototype> = {
     [Term in Namespace["terms"][number]]: `${NamespacePrefix<Namespace>}${Term}`;
 };
 export declare const createNamespace: <N extends NamespacePrototype, I = NamespaceIri<N>, P = NamespacePrefix<N>, O = NamespaceObject<N>>(namespaceSpec: N) => O & {

package/types/library/rdf.d.ts

@@ -4,15 +4,15 @@ export { fromRdf, toRdf } from "rdf-literal";
 import { DataFactory, DefaultGraph } from "rdf-data-factory";
 export { DataFactory, DefaultGraph };
 import type { IDataSource, IQueryContextCommon } from "@comunica/types";
-export declare type LDkitContext = {
+export type LDkitContext = {
     graph?: string;
     language?: string;
 };
-export declare type Context = LDkitContext & RDF.QueryStringContext & RDF.QuerySourceContext<IDataSource> & IQueryContextCommon;
-export declare type IQueryEngine = RDF.StringSparqlQueryable<RDF.SparqlResultSupport, Context>;
-export declare type Iri = string;
-export declare type Node = Map<Iri, RDF.Term[]>;
-export declare type Graph = Map<Iri, Node>;
+export type Context = LDkitContext & RDF.QueryStringContext & RDF.QuerySourceContext<IDataSource> & IQueryContextCommon;
+export type IQueryEngine = RDF.StringSparqlQueryable<RDF.SparqlResultSupport, Context>;
+export type Iri = string;
+export type Node = Map<Iri, RDF.Term[]>;
+export type Graph = Map<Iri, Node>;
 export declare const quadsToGraph: (quads: RDF.Quad[]) => Graph;
 export declare namespace RDFJSON {
     type Term = {

package/types/library/schema/data_types.d.ts

@@ -34,6 +34,6 @@ declare const SupportedDataTypesPrototype: {
     "xsd:hexBinary": string;
     "rdf:langString": string;
 };
-export declare type SupportedDataTypes = typeof SupportedDataTypesPrototype;
-export declare type SupportedNativeTypes = SupportedDataTypes[keyof SupportedDataTypes];
+export type SupportedDataTypes = typeof SupportedDataTypesPrototype;
+export type SupportedNativeTypes = SupportedDataTypes[keyof SupportedDataTypes];
 export {};

package/types/library/schema/interface.d.ts

@@ -1,32 +1,32 @@
 import type { SupportedDataTypes } from "./data_types.js";
 import type { PropertyPrototype, SchemaPrototype } from "./schema.js";
-declare type IsOptional<Property extends PropertyPrototype> = Property extends {
+type IsOptional<Property extends PropertyPrototype> = Property extends {
     "@optional": true;
 } ? true : false;
-declare type IsArray<Property extends PropertyPrototype> = Property extends {
+type IsArray<Property extends PropertyPrototype> = Property extends {
     "@array": true;
 } ? true : false;
-declare type IsMultilang<Property extends PropertyPrototype> = Property extends {
+type IsMultilang<Property extends PropertyPrototype> = Property extends {
     "@multilang": true;
 } ? true : false;
-declare type ValidPropertyDefinition = PropertyPrototype | string;
-declare type ConvertPropertyType<T extends PropertyPrototype> = T extends {
+type ValidPropertyDefinition = PropertyPrototype | string;
+type ConvertPropertyType<T extends PropertyPrototype> = T extends {
     "@context": SchemaPrototype;
 } ? SchemaInterface<T["@context"]> : T extends {
     "@type": unknown;
 } ? T["@type"] extends keyof SupportedDataTypes ? SupportedDataTypes[T["@type"]] : never : string;
-declare type ConvertPropertyOptional<T extends PropertyPrototype> = IsOptional<T> extends true ? ConvertPropertyType<T> | undefined : ConvertPropertyType<T>;
-declare type ConvertPropertyArray<T extends PropertyPrototype> = IsArray<T> extends true ? ConvertPropertyType<T>[] : ConvertPropertyOptional<T>;
-declare type ConvertPropertyMultilang<T extends PropertyPrototype> = IsMultilang<T> extends true ? IsArray<T> extends true ? Record<string, ConvertPropertyType<T>[]> : Record<string, ConvertPropertyType<T>> : ConvertPropertyArray<T>;
-declare type ConvertPropertyObject<T extends PropertyPrototype> = ConvertPropertyMultilang<T>;
-declare type ConvertProperty<T extends ValidPropertyDefinition> = T extends PropertyPrototype ? ConvertPropertyObject<T> : string;
-export declare type SchemaInterfaceIdentity = {
+type ConvertPropertyOptional<T extends PropertyPrototype> = IsOptional<T> extends true ? ConvertPropertyType<T> | undefined : ConvertPropertyType<T>;
+type ConvertPropertyArray<T extends PropertyPrototype> = IsArray<T> extends true ? ConvertPropertyType<T>[] : ConvertPropertyOptional<T>;
+type ConvertPropertyMultilang<T extends PropertyPrototype> = IsMultilang<T> extends true ? IsArray<T> extends true ? Record<string, ConvertPropertyType<T>[]> : Record<string, ConvertPropertyType<T>> : ConvertPropertyArray<T>;
+type ConvertPropertyObject<T extends PropertyPrototype> = ConvertPropertyMultilang<T>;
+type ConvertProperty<T extends ValidPropertyDefinition> = T extends PropertyPrototype ? ConvertPropertyObject<T> : string;
+export type SchemaInterfaceIdentity = {
     $id: string;
 };
-export declare type SchemaInterfaceType = {
+export type SchemaInterfaceType = {
     $type: string[];
 };
-export declare type SchemaInterface<T extends SchemaPrototype> = {
+export type SchemaInterface<T extends SchemaPrototype> = {
     [X in Exclude<keyof T, "@type">]: T[X] extends ValidPropertyDefinition ? ConvertProperty<T[X]> : never;
 } & SchemaInterfaceIdentity & SchemaInterfaceType;
 export {};

package/types/library/schema/schema.d.ts

@@ -1,6 +1,6 @@
 import type { SupportedDataTypes } from "./data_types.js";
-declare type PropertyType = keyof SupportedDataTypes;
-export declare type PropertyPrototype = {
+type PropertyType = keyof SupportedDataTypes;
+export type PropertyPrototype = {
     "@id": string;
     "@type"?: PropertyType;
     "@context"?: SchemaPrototype;
@@ -8,14 +8,14 @@ export declare type PropertyPrototype = {
     "@array"?: true;
     "@multilang"?: true;
 };
-export declare type SchemaPrototypeProperties = {
+export type SchemaPrototypeProperties = {
     [key: string]: PropertyPrototype | string | readonly string[];
 };
-export declare type SchemaPrototypeType = {
+export type SchemaPrototypeType = {
     "@type": string | readonly string[];
 };
-export declare type SchemaPrototype = SchemaPrototypeProperties & SchemaPrototypeType;
-export declare type Property = {
+export type SchemaPrototype = SchemaPrototypeProperties & SchemaPrototypeType;
+export type Property = {
     "@id": string;
     "@type"?: PropertyType;
     "@context"?: Schema;
@@ -23,7 +23,7 @@ export declare type Property = {
     "@array"?: true;
     "@multilang"?: true;
 };
-export declare type Schema = {
+export type Schema = {
     [key: string]: Property | string[];
     "@type": string[];
 };