@manta-eu/react 0.1.0

package/dist/hooks/use-action-plan-execution-provenance.js

@@ -0,0 +1,250 @@
+import { vocabBase } from "@manta-eu/ldo/realm";
+import { prependMissingSparqlPrefixes } from "@manta-eu/rdf-lib/namespaces";
+import { useQuery } from "@tanstack/react-query";
+import { DataFactory } from "ldkit/rdf";
+import { SELECT } from "ldkit/sparql";
+import { match } from "ts-pattern";
+import { extractLabel } from "../lib/iri-labels.js";
+import { collectBindings } from "../lib/rdf-helpers.js";
+import { optionsToContext, useSparqlEngine, useSparqlOptions } from "./use-sparql-options.js";
+const df = new DataFactory();
+const provStartedAtTime = "http://www.w3.org/ns/prov#startedAtTime";
+const provEndedAtTime = "http://www.w3.org/ns/prov#endedAtTime";
+const provUsed = "http://www.w3.org/ns/prov#used";
+const provGenerated = "http://www.w3.org/ns/prov#generated";
+const provInvalidated = "http://www.w3.org/ns/prov#invalidated";
+const provWasAssociatedWith = "http://www.w3.org/ns/prov#wasAssociatedWith";
+const provWasInformedBy = "http://www.w3.org/ns/prov#wasInformedBy";
+const vocabOperationType = `${vocabBase}operationType`;
+const vocabErrorMessage = `${vocabBase}errorMessage`;
+const vocabDryRun = `${vocabBase}dryRun`;
+function buildExecutionProvenanceQuery(planGraphIri) {
+    const planNode = df.namedNode(planGraphIri);
+    return prependMissingSparqlPrefixes(SELECT `?activity ?predicate ?object ?parentActivity`.WHERE `
+    ?activity a prov:Activity ;
+              ?predicate ?object .
+    OPTIONAL { ?activity prov:wasInformedBy ?parentActivity . }
+    {
+      ?activity prov:used ${planNode} .
+    }
+    UNION
+    {
+      ?activity prov:wasInformedBy+ ?rootActivity .
+      ?rootActivity a prov:Activity ;
+                    prov:used ${planNode} .
+    }
+  `.ORDER_BY `?activity ?predicate ?object`.build());
+}
+function bindingVal(binding, key) {
+    return binding.get(key)?.value;
+}
+function createEntity(iri, relation) {
+    const resolvedLabel = extractLabel(iri) ?? null;
+    return {
+        iri,
+        label: resolvedLabel || null,
+        typeName: extractEntityTypeName(iri),
+        relation,
+    };
+}
+function extractEntityTypeName(iri) {
+    const fragment = extractLabel(iri);
+    if (!fragment) {
+        return null;
+    }
+    const [typeName] = fragment.split("_");
+    return typeName || null;
+}
+function appendEntity(activity, entity) {
+    if (!entity) {
+        return;
+    }
+    activity.entities.set(`${entity.relation}:${entity.iri}`, entity);
+}
+function selectPrimaryEntity(entities) {
+    return (entities.find((entity) => entity.relation === "invalidated") ??
+        entities.find((entity) => entity.relation === "used") ??
+        entities.find((entity) => entity.relation === "generated") ??
+        null);
+}
+function processExecutionProvenanceBindings(bindings, planGraphIri) {
+    const activityMap = new Map();
+    for (const binding of bindings) {
+        const activityIri = bindingVal(binding, "activity");
+        const predicateIri = bindingVal(binding, "predicate");
+        const objectValue = bindingVal(binding, "object");
+        const parentActivityIri = bindingVal(binding, "parentActivity") ?? null;
+        if (!activityIri) {
+            continue;
+        }
+        if (!activityMap.has(activityIri)) {
+            activityMap.set(activityIri, {
+                iri: activityIri,
+                parentActivityIri,
+                directlyUsesPlan: false,
+                startedAtTime: null,
+                endedAtTime: null,
+                operationType: null,
+                errorMessage: null,
+                dryRun: false,
+                associatedAgentIris: new Set(),
+                entities: new Map(),
+            });
+        }
+        const entry = activityMap.get(activityIri);
+        if (!entry) {
+            continue;
+        }
+        if (!predicateIri || objectValue == null) {
+            continue;
+        }
+        if (parentActivityIri && !entry.parentActivityIri) {
+            entry.parentActivityIri = parentActivityIri;
+        }
+        match(predicateIri)
+            .with(provWasInformedBy, () => {
+            entry.parentActivityIri = objectValue;
+        })
+            .with(provStartedAtTime, () => {
+            entry.startedAtTime = objectValue;
+        })
+            .with(provEndedAtTime, () => {
+            entry.endedAtTime = objectValue;
+        })
+            .with(vocabOperationType, () => {
+            entry.operationType = objectValue;
+        })
+            .with(vocabErrorMessage, () => {
+            entry.errorMessage = objectValue;
+        })
+            .with(vocabDryRun, () => {
+            entry.dryRun = objectValue === "true";
+        })
+            .with(provUsed, () => {
+            if (objectValue === planGraphIri)
+                entry.directlyUsesPlan = true;
+            else
+                appendEntity(entry, createEntity(objectValue, "used"));
+        })
+            .with(provGenerated, () => appendEntity(entry, createEntity(objectValue, "generated")))
+            .with(provInvalidated, () => appendEntity(entry, createEntity(objectValue, "invalidated")))
+            .with(provWasAssociatedWith, () => {
+            entry.associatedAgentIris.add(objectValue);
+        })
+            .otherwise(() => { });
+    }
+    const rootActivities = Array.from(activityMap.values())
+        .filter((activity) => activity.directlyUsesPlan)
+        .sort(compareActivitiesByStartedAtDesc);
+    const planActivity = rootActivities[0] ?? null;
+    const descendantActivities = planActivity
+        ? collectDescendantActivities(planActivity.iri, activityMap).sort(compareActivitiesByStartedAtAsc)
+        : [];
+    const visibleActivities = planActivity
+        ? descendantActivities.length > 0
+            ? descendantActivities
+            : [planActivity]
+        : Array.from(activityMap.values())
+            .filter((activity) => !activity.directlyUsesPlan)
+            .sort(compareActivitiesByStartedAtAsc);
+    const activities = visibleActivities.map((activity) => {
+        const entities = Array.from(activity.entities.values());
+        const primaryEntity = selectPrimaryEntity(entities);
+        return {
+            iri: activity.iri,
+            parentActivityIri: activity.parentActivityIri,
+            isPlanActivity: activity.directlyUsesPlan,
+            startedAtTime: activity.startedAtTime,
+            endedAtTime: activity.endedAtTime,
+            operationType: activity.operationType,
+            errorMessage: activity.errorMessage,
+            dryRun: activity.dryRun,
+            associatedAgentIris: Array.from(activity.associatedAgentIris.values()),
+            entityIri: primaryEntity?.iri ?? null,
+            entityLabel: primaryEntity?.label ?? primaryEntity?.typeName ?? extractLabel(activity.iri) ?? "Execution target",
+            entityTypeName: primaryEntity?.typeName ?? null,
+            entities,
+        };
+    });
+    return {
+        planActivityIri: planActivity?.iri ?? null,
+        planStartedAtTime: planActivity?.startedAtTime ?? null,
+        planEndedAtTime: planActivity?.endedAtTime ?? null,
+        planErrorMessage: planActivity?.errorMessage ?? null,
+        planDryRun: planActivity?.dryRun ?? false,
+        activities,
+        count: activities.length,
+        error: null,
+    };
+}
+function compareActivitiesByStartedAtAsc(left, right) {
+    const leftTime = parseSortableTimestamp(left.startedAtTime, Number.POSITIVE_INFINITY);
+    const rightTime = parseSortableTimestamp(right.startedAtTime, Number.POSITIVE_INFINITY);
+    if (leftTime !== rightTime) {
+        return leftTime - rightTime;
+    }
+    return left.iri.localeCompare(right.iri);
+}
+function compareActivitiesByStartedAtDesc(left, right) {
+    const leftTime = parseSortableTimestamp(left.startedAtTime, Number.NEGATIVE_INFINITY);
+    const rightTime = parseSortableTimestamp(right.startedAtTime, Number.NEGATIVE_INFINITY);
+    if (leftTime !== rightTime) {
+        return rightTime - leftTime;
+    }
+    return right.iri.localeCompare(left.iri);
+}
+function parseSortableTimestamp(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const timestamp = Date.parse(value);
+    return Number.isNaN(timestamp) ? fallback : timestamp;
+}
+function collectDescendantActivities(rootActivityIri, activityMap) {
+    const childrenByParent = new Map();
+    for (const activity of activityMap.values()) {
+        if (!activity.parentActivityIri)
+            continue;
+        let children = childrenByParent.get(activity.parentActivityIri);
+        if (!children) {
+            children = [];
+            childrenByParent.set(activity.parentActivityIri, children);
+        }
+        children.push(activity);
+    }
+    const descendants = [];
+    const queue = [rootActivityIri];
+    const seen = new Set(queue);
+    while (queue.length > 0) {
+        const parentIri = queue.shift();
+        if (!parentIri)
+            continue;
+        for (const child of childrenByParent.get(parentIri) ?? []) {
+            if (seen.has(child.iri))
+                continue;
+            descendants.push(child);
+            queue.push(child.iri);
+            seen.add(child.iri);
+        }
+    }
+    return descendants;
+}
+export function useActionPlanExecutionProvenance(config) {
+    const { planGraphIri, enabled = true, refetchIntervalMs = false } = config;
+    const engine = useSparqlEngine();
+    const options = useSparqlOptions();
+    return useQuery({
+        queryKey: ["ldo-ui", planGraphIri, "action-plan-execution-provenance", engine, options],
+        queryFn: async () => {
+            const query = buildExecutionProvenanceQuery(planGraphIri);
+            const stream = await engine.queryBindings(query, optionsToContext(options));
+            const bindings = await collectBindings(stream);
+            return processExecutionProvenanceBindings(bindings, planGraphIri);
+        },
+        enabled: enabled && !!planGraphIri,
+        refetchInterval: refetchIntervalMs,
+        refetchIntervalInBackground: true,
+        refetchOnMount: "always",
+        refetchOnWindowFocus: "always",
+    });
+}

package/dist/hooks/use-action-plan-graph.d.ts

@@ -0,0 +1,8 @@
+export type UseActionPlanGraphOptions = {
+    planGraphIri: string;
+    typeIri?: string;
+    limit?: number;
+    enabled?: boolean;
+};
+export declare function useActionPlanGraph(config: UseActionPlanGraphOptions): import("@tanstack/react-query").UseQueryResult<import("../ldo-ui.js").RdfGraph, Error>;
+//# sourceMappingURL=use-action-plan-graph.d.ts.map

package/dist/hooks/use-action-plan-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-action-plan-graph.d.ts","sourceRoot":"","sources":["../../src/hooks/use-action-plan-graph.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,yBAAyB,GAAG;IACtC,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AA+BF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,yBAAyB,uFAUnE"}

package/dist/hooks/use-action-plan-graph.js

@@ -0,0 +1,37 @@
+import { prependMissingSparqlPrefixes } from "@manta-eu/rdf-lib/namespaces";
+import { useSparqlConstruct } from "./use-sparql-construct.js";
+function clampLimit(limit, defaultLimit, maxLimit) {
+    const value = limit ?? defaultLimit;
+    return Math.min(Math.max(1, value), maxLimit);
+}
+function buildActionPlanGraphQuery(planGraphIri, typeIri, limit) {
+    const validatedLimit = clampLimit(limit, 20, 200);
+    const typeFilter = typeIri ? `?subject a <${typeIri}> .` : "";
+    return prependMissingSparqlPrefixes(`
+    CONSTRUCT {
+      ?subject ?predicate ?object .
+      ?subject a ?type .
+      ?subject rdfs:label ?label .
+      ?object rdfs:label ?objectLabel .
+    }
+    WHERE {
+      GRAPH <${planGraphIri}> {
+        ${typeFilter}
+        ?subject ?predicate ?object EXPLICIT FALSE .
+        OPTIONAL { ?subject a ?type }
+        OPTIONAL { ?subject rdfs:label ?label }
+        OPTIONAL { ?object rdfs:label ?objectLabel }
+      }
+    }
+    LIMIT ${validatedLimit}
+  `);
+}
+export function useActionPlanGraph(config) {
+    const { planGraphIri, typeIri, limit, enabled = true } = config;
+    const query = buildActionPlanGraphQuery(planGraphIri, typeIri, limit);
+    return useSparqlConstruct({
+        query,
+        queryKey: ["ldo-ui", planGraphIri, "action-plan-graph", typeIri],
+        enabled: enabled && !!planGraphIri,
+    });
+}

package/dist/hooks/use-action-plan-provenance.d.ts

@@ -0,0 +1,28 @@
+export type ProvenanceAgent = {
+    iri: string;
+    type: "SoftwareAgent" | "Person";
+    label: string | null;
+};
+export type ProvenanceActivity = {
+    iri: string;
+    startedAtTime: string | null;
+    endedAtTime: string | null;
+    operationType: string | null;
+    errorMessage: string | null;
+    dryRun: boolean;
+    agents: ProvenanceAgent[];
+    generatedCount: number;
+    invalidatedCount: number;
+};
+export type ProvenanceResult = {
+    activities: ProvenanceActivity[];
+    count: number;
+    error: string | null;
+};
+export type UseActionPlanProvenanceOptions = {
+    planGraphIri: string;
+    limit?: number;
+    enabled?: boolean;
+};
+export declare function useActionPlanProvenance(config: UseActionPlanProvenanceOptions): import("@tanstack/react-query").UseQueryResult<ProvenanceResult, Error>;
+//# sourceMappingURL=use-action-plan-provenance.d.ts.map

package/dist/hooks/use-action-plan-provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-action-plan-provenance.d.ts","sourceRoot":"","sources":["../../src/hooks/use-action-plan-provenance.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,eAAe,GAAG,QAAQ,CAAC;IACjC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,kBAAkB,EAAE,CAAC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG;IAC3C,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAiHF,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,8BAA8B,2EAgB7E"}

package/dist/hooks/use-action-plan-provenance.js

@@ -0,0 +1,110 @@
+import { prependMissingSparqlPrefixes } from "@manta-eu/rdf-lib/namespaces";
+import { useQuery } from "@tanstack/react-query";
+import { DataFactory } from "ldkit/rdf";
+import { SELECT } from "ldkit/sparql";
+import { extractLabel } from "../lib/iri-labels.js";
+import { collectBindings } from "../lib/rdf-helpers.js";
+import { useSparqlEngine, useSparqlOptions } from "./use-sparql-options.js";
+const df = new DataFactory();
+function buildProvenanceQuery(planGraphIri, limit) {
+    return prependMissingSparqlPrefixes(SELECT `
+    ?activity ?startedAt ?endedAt ?operationType ?errorMessage ?dryRun
+    ?agent ?agentType ?agentLabel ?generated ?invalidated
+  `.WHERE `
+    ?activity a prov:Activity ;
+              prov:used ${df.namedNode(planGraphIri)} .
+    OPTIONAL { ?activity prov:startedAtTime ?startedAt }
+    OPTIONAL { ?activity prov:endedAtTime ?endedAt }
+    OPTIONAL { ?activity :operationType ?operationType }
+    OPTIONAL { ?activity :errorMessage ?errorMessage }
+    OPTIONAL { ?activity :dryRun ?dryRun }
+    OPTIONAL {
+      ?activity prov:wasAssociatedWith ?agent .
+      ?agent a ?agentType .
+      OPTIONAL { ?agent rdfs:label ?agentLabel }
+    }
+    OPTIONAL { ?activity prov:generated ?generated }
+    OPTIONAL { ?activity prov:invalidated ?invalidated }
+  `.ORDER_BY `DESC(?startedAt)`
+        .LIMIT(limit)
+        .build());
+}
+function bindingVal(binding, key) {
+    return binding.get(key)?.value;
+}
+function parseAgentType(typeIri) {
+    if (typeIri.includes("Person"))
+        return "Person";
+    return "SoftwareAgent";
+}
+function processProvenanceBindings(bindings) {
+    const activityMap = new Map();
+    for (const binding of bindings) {
+        const activityIri = bindingVal(binding, "activity");
+        if (!activityIri)
+            continue;
+        if (!activityMap.has(activityIri)) {
+            activityMap.set(activityIri, {
+                iri: activityIri,
+                startedAtTime: bindingVal(binding, "startedAt") ?? null,
+                endedAtTime: bindingVal(binding, "endedAt") ?? null,
+                operationType: bindingVal(binding, "operationType") ?? null,
+                errorMessage: bindingVal(binding, "errorMessage") ?? null,
+                dryRun: bindingVal(binding, "dryRun") === "true",
+                agents: new Map(),
+                generated: new Set(),
+                invalidated: new Set(),
+            });
+        }
+        const entry = activityMap.get(activityIri);
+        const agentIri = bindingVal(binding, "agent");
+        if (agentIri && !entry.agents.has(agentIri)) {
+            const agentTypeIri = bindingVal(binding, "agentType");
+            entry.agents.set(agentIri, {
+                iri: agentIri,
+                type: agentTypeIri ? parseAgentType(agentTypeIri) : "SoftwareAgent",
+                label: bindingVal(binding, "agentLabel") ?? extractLabel(agentIri),
+            });
+        }
+        const generatedIri = bindingVal(binding, "generated");
+        if (generatedIri) {
+            entry.generated.add(generatedIri);
+        }
+        const invalidatedIri = bindingVal(binding, "invalidated");
+        if (invalidatedIri) {
+            entry.invalidated.add(invalidatedIri);
+        }
+    }
+    const activities = Array.from(activityMap.values()).map((entry) => ({
+        iri: entry.iri,
+        startedAtTime: entry.startedAtTime,
+        endedAtTime: entry.endedAtTime,
+        operationType: entry.operationType,
+        errorMessage: entry.errorMessage,
+        dryRun: entry.dryRun,
+        agents: Array.from(entry.agents.values()),
+        generatedCount: entry.generated.size,
+        invalidatedCount: entry.invalidated.size,
+    }));
+    return {
+        activities,
+        count: activities.length,
+        error: null,
+    };
+}
+export function useActionPlanProvenance(config) {
+    const { planGraphIri, limit = 20, enabled = true } = config;
+    const engine = useSparqlEngine();
+    const options = useSparqlOptions();
+    const context = options;
+    return useQuery({
+        queryKey: ["ldo-ui", planGraphIri, "action-plan-provenance", limit, engine, context],
+        queryFn: async () => {
+            const query = buildProvenanceQuery(planGraphIri, limit);
+            const stream = await engine.queryBindings(query, context);
+            const bindings = await collectBindings(stream);
+            return processProvenanceBindings(bindings);
+        },
+        enabled: enabled && !!planGraphIri,
+    });
+}

package/dist/hooks/use-action-plan-samples.d.ts

@@ -0,0 +1,25 @@
+import type { PropertyChange } from "../lib/iri-labels.js";
+export type PlanOperation = "ADDED" | "UPDATED";
+export type PlanSample = {
+    subject: string;
+    label?: string;
+    hierarchyLabel?: string;
+    description?: string;
+    operation: PlanOperation;
+    properties: PropertyChange[];
+};
+export type PlanSamplesResult = {
+    samples: PlanSample[];
+    count: number;
+    typeIri: string;
+    typeName: string;
+    error: string | null;
+};
+export type UseActionPlanSamplesOptions = {
+    planGraphIri: string;
+    typeIri: string;
+    limit?: number;
+    enabled?: boolean;
+};
+export declare function useActionPlanSamples(config: UseActionPlanSamplesOptions): import("@tanstack/react-query").UseQueryResult<PlanSamplesResult, Error>;
+//# sourceMappingURL=use-action-plan-samples.d.ts.map

package/dist/hooks/use-action-plan-samples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-action-plan-samples.d.ts","sourceRoot":"","sources":["../../src/hooks/use-action-plan-samples.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAsB,MAAM,mBAAmB,CAAC;AAS5E,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,SAAS,CAAC;AAEhD,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,cAAc,EAAE,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAuPF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,2BAA2B,4EA6BvE"}