@oxilite/common 0.2.2 → 0.5.0

package/dist/index.d.ts

@@ -130,6 +130,16 @@ export interface QueryOptions {
     reasoning?: "none" | "rdfs" | "owl-ql";
     /** Also match inferences stored by `materialize()` (oxilite extension). */
     include_inferred?: boolean;
+    /**
+     * Match the triples of registered schema graphs (oxilite extension, default true); `false`
+     * queries the data without the ontologies and shapes that describe it.
+     */
+    include_schema_graphs?: boolean;
+    /**
+     * Read the store as it was at this version (oxilite extension, versioning `log`):
+     * `"HEAD~2"`, `"#42"` (a tick) or `"@2026-09-01T12:00:00Z"`.
+     */
+    as_of?: string;
 }
 /** Load options (Oxigraph's JS option names). */
 export interface LoadOptions {
@@ -194,6 +204,42 @@ export interface CypherResult {
     records: Record<string, CypherValue>[];
     stats: CypherStats;
 }
+/** Options of the Datalog frontend (see `oxilite_datalog::json`). */
+export interface DatalogOptions {
+    /** Match every graph rather than only the default graph. */
+    useDefaultGraphAsUnion?: boolean;
+    /** Also match materialized inferences. */
+    includeInferred?: boolean;
+    /** Rounds a component evaluated by iteration may take (default 100). */
+    maxIterations?: number;
+    /** Run the program on this version of the store (like an `@version` directive). */
+    asOf?: string;
+}
+/** What the native side returns for a Datalog program. */
+export interface DatalogOutput {
+    kind: "datalog";
+    columns: string[];
+    rows: (TermJson | null)[][];
+    /** Rounds each iterated component took; empty when nothing had to be iterated. */
+    rounds: number[];
+}
+/** The solutions of a Datalog program, as RDF/JS terms. */
+export interface DatalogResult {
+    columns: string[];
+    rows: (Term | null)[][];
+    /** Rows as objects keyed by the goal's variables. */
+    records: Record<string, Term | null>[];
+    rounds: number[];
+}
+/** What a materialization did. */
+export interface DatalogMaterializeResult {
+    kind: "datalogMaterialize";
+    /** Triples in the inference table afterwards. */
+    inferred: number;
+    /** Relations whose conclusions were stored. */
+    relations: number;
+}
+export declare function datalogResult(out: DatalogOutput): DatalogResult;
 /** Options of the Cypher frontend (see `oxilite_cypher::json`). */
 export interface CypherOptions {
     /** Namespace of labels, relationship types and keys without a prefix (default `urn:oxilite:pg:`). */
@@ -210,6 +256,11 @@ export interface CypherOptions {
     shortestPathCap?: number;
     /** Check writes against the SHACL shapes of the dataset (default true). */
     shapes?: boolean;
+    /**
+     * Match the store as it was at this version (versioning `log`): `"HEAD~1"`, `"#42"` or
+     * `"@2026-09-01T12:00:00Z"`. Writing statements are refused with a version.
+     */
+    asOf?: string;
     /** Give created nodes an `rdf:type rdfs:Resource` triple (default true). */
     nodeMarker?: boolean;
     /** Entailment for matching: `"rdfs"` or `"owl-ql"` make labels follow class hierarchies. */
@@ -321,4 +372,119 @@ export declare function storedDocument(j: Record<string, unknown> | null): Store
 export declare function filterJson(f: DocumentFilter): Record<string, unknown>;
 /** A document argument: JSON text is stored verbatim, objects are serialized. */
 export declare function documentText(doc: string | object): string;
+/** How much history a store keeps. */
+export type Versioning = "off" | "stamped" | "log";
+/** The versioning level of a store and where its clock and history stand. */
+export interface VersionStatus {
+    level: Versioning;
+    history: "none" | "live" | "frozen";
+    stampColumn: boolean;
+    stampIndex: boolean;
+    asOfIndex: boolean;
+    /** The latest tick. */
+    head: number | null;
+    /** Wall time of the latest tick, in seconds since the epoch. */
+    headTime: number | null;
+    /** Where the recorded history (re)starts. */
+    genesis: number | null;
+    /** The latest freeze, while the history is frozen. */
+    frozenAt: number | null;
+    commits: number | null;
+}
+/** One entry of the history: a commit or a level change. */
+export interface CommitRecord {
+    tick: number;
+    /** Seconds since the epoch. */
+    time: number;
+    kind: "write" | "genesis" | "freeze" | "resume" | "dropped" | "level" | "purge";
+    author: string | null;
+    message: string | null;
+    added: number | null;
+    removed: number | null;
+}
+/** A quad added or removed at a tick. */
+export interface Change {
+    tick: number;
+    added: boolean;
+    quad: Quad;
+}
+/** Options of a level change. */
+export interface LevelChange {
+    asOfIndex?: boolean;
+    stampIndex?: boolean;
+    /** Allow a downgrade to delete the history, the ticks and the stamp column. */
+    allowLoss?: boolean;
+    author?: string;
+    message?: string;
+}
+/** Author and message recorded on the commits of later writes. */
+export interface CommitInfo {
+    author?: string;
+    message?: string;
+}
+/** Changes from their JSON form (`{tick, added, quad}`). */
+export declare function toChanges(v: unknown): Change[];
+/** The system graph holding the schema registry. */
+export declare const SCHEMA_GRAPH = "oxilite:schema";
+/** The oxilite vocabulary namespace (`oxl:`). */
+export declare const OXL = "https://oxilite.dev/ns#";
+/** Names the default graph in the registry (as a schema graph or an `appliesTo` target). */
+export declare const DEFAULT_GRAPH_IRI = "https://oxilite.dev/ns#DefaultGraph";
+/** What a registered graph holds. */
+export type SchemaRole = "ontology" | "shacl" | "shex";
+/** What is recorded about a graph when it is registered (every field optional). */
+export interface SchemaRegistration {
+    /** The `owl:Ontology` IRI, when it differs from the graph name. */
+    iri?: string;
+    /** `owl:versionIRI`, a version string, or anything else worth pinning. */
+    version?: string;
+    /** Digest of the document the graph was loaded from, for drift detection. */
+    sha256?: string;
+    /** `owl:imports` targets, recorded but not resolved. */
+    imports?: string[];
+    /**
+     * The graphs the schema applies to (`oxl:appliesTo`): IRIs, or `DEFAULT_GRAPH_IRI`. Absent or
+     * empty: every graph.
+     */
+    appliesTo?: GraphArg[];
+    /** An inactive graph stays registered (and hidden) but stops contributing (default true). */
+    active?: boolean;
+}
+/** One entry of the schema registry. */
+export interface SchemaGraphEntry {
+    graph: Term;
+    role: SchemaRole;
+    iri: string | null;
+    version: string | null;
+    sha256: string | null;
+    imports: string[];
+    /** The graphs the schema applies to (IRIs, `DEFAULT_GRAPH_IRI`); empty: every graph. */
+    appliesTo: string[];
+    active: boolean;
+    /** When the graph was registered (`xsd:dateTime`). */
+    loadedAt: string | null;
+}
+/** One compiled SHACL property shape: every constraint declared on a target class and path. */
+export interface PropertyShapeEntry {
+    target: string;
+    path: string;
+    datatype: string | null;
+    minCount: number | null;
+    maxCount: number | null;
+    pattern: string | null;
+    /** The `sh:in` values. */
+    in: Term[];
+    /** Relationship-valued (`sh:class` / `sh:node`). */
+    relationship: boolean;
+}
+/** A graph argument: an RDF/JS term, or an IRI string. */
+export type GraphArg = TermLike | string;
+/** The JSON text of a graph argument. */
+export declare function graphJson(g: GraphArg): string;
+/** A registration's JSON text. */
+export declare function registrationJson(r?: SchemaRegistration): string;
+/** Registry entries from their JSON form. */
+export declare function toSchemaGraphs(v: unknown): SchemaGraphEntry[];
+/** Shape index entries from their JSON form. */
+export declare function toShapeIndex(v: unknown): PropertyShapeEntry[];
 export {};

package/dist/index.js

@@ -209,6 +209,15 @@ export function loadDataToString(data) {
     const one = (d) => (typeof d === "string" ? d : new TextDecoder().decode(d));
     return Array.isArray(data) ? data.map(one).join("\n") : one(data);
 }
+export function datalogResult(out) {
+    const rows = out.rows.map((row) => row.map((c) => (c === null ? null : fromJson(c))));
+    return {
+        columns: out.columns,
+        rows,
+        records: rows.map((row) => Object.fromEntries(out.columns.map((c, i) => [c, row[i] ?? null]))),
+        rounds: out.rounds,
+    };
+}
 export function cypherResult(out) {
     return {
         columns: out.columns,
@@ -269,3 +278,45 @@ export function filterJson(f) {
 export function documentText(doc) {
     return typeof doc === "string" ? doc : JSON.stringify(doc);
 }
+/** Changes from their JSON form (`{tick, added, quad}`). */
+export function toChanges(v) {
+    return v.map((c) => ({
+        tick: c.tick,
+        added: c.added,
+        quad: fromJson(c.quad),
+    }));
+}
+// ------------------------------------------------------------------------- schema registry
+//
+// The registry is RDF in the system graph <oxilite:schema> (vocabulary: https://oxilite.dev/ns#):
+// each registered graph is typed oxl:OntologyGraph, oxl:ShapesGraph or oxl:ShExGraph and names
+// the graphs it applies to with oxl:appliesTo. The same triples work on any SPARQL store.
+/** The system graph holding the schema registry. */
+export const SCHEMA_GRAPH = "oxilite:schema";
+/** The oxilite vocabulary namespace (`oxl:`). */
+export const OXL = "https://oxilite.dev/ns#";
+/** Names the default graph in the registry (as a schema graph or an `appliesTo` target). */
+export const DEFAULT_GRAPH_IRI = "https://oxilite.dev/ns#DefaultGraph";
+/** The JSON text of a graph argument. */
+export function graphJson(g) {
+    return JSON.stringify(typeof g === "string" ? { termType: "NamedNode", value: g } : toJson(g));
+}
+/** A registration's JSON text. */
+export function registrationJson(r = {}) {
+    const iri = (g) => (typeof g === "string" ? g : g.termType === "DefaultGraph" ? DEFAULT_GRAPH_IRI : g.value);
+    return JSON.stringify({ ...r, appliesTo: r.appliesTo?.map(iri) });
+}
+/** Registry entries from their JSON form. */
+export function toSchemaGraphs(v) {
+    return v.map((e) => ({
+        ...e,
+        graph: fromJson(e.graph),
+    }));
+}
+/** Shape index entries from their JSON form. */
+export function toShapeIndex(v) {
+    return v.map((e) => ({
+        ...e,
+        in: e.in.map(fromJson),
+    }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxilite/common",
-  "version": "0.2.2",
+  "version": "0.5.0",
   "description": "RDF/JS terms and result conversion shared by the oxilite JavaScript packages",
   "license": "MIT OR Apache-2.0",
   "type": "module",