@lde/pipeline-void 0.2.37 → 0.3.0

package/README.md

@@ -1,71 +1,67 @@
-# Pipeline VOiD
+# Pipeline VoID
 
-VOiD (Vocabulary of Interlinked Datasets) statistical analysis for RDF datasets.
+Extensions to [@lde/pipeline](../pipeline) for VoID (Vocabulary of Interlinked Datasets) statistical analysis of RDF datasets.
 
-## Query stages
+## Stage factories
 
-- `createQueryStage(filename, distribution)` — Create a `Stage` from a SPARQL CONSTRUCT query file
-- `createDatatypeStage(distribution)` — Per-class datatype partitions
-- `createLanguageStage(distribution)` — Per-class language tags
-- `createObjectClassStage(distribution)` — Per-class object class partitions
+### Global stages (one CONSTRUCT query per dataset):
 
-## Executor decorators
+| Factory                                | Query                                                                                                              |
+| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| `createClassPartitionStage()`          | [`class-partition.rq`](src/queries/class-partition.rq) — Classes with entity counts                                |
+| `createClassPropertiesSubjectsStage()` | [`class-properties-subjects.rq`](src/queries/class-properties-subjects.rq) — Properties per class (subject counts) |
+| `createClassPropertiesObjectsStage()`  | [`class-properties-objects.rq`](src/queries/class-properties-objects.rq) — Properties per class (object counts)    |
+| `createDatatypesStage()`               | [`datatypes.rq`](src/queries/datatypes.rq) — Dataset-level datatypes                                               |
+| `createLicensesStage()`                | [`licenses.rq`](src/queries/licenses.rq) — License detection                                                       |
+| `createObjectLiteralsStage()`          | [`object-literals.rq`](src/queries/object-literals.rq) — Literal object counts                                     |
+| `createObjectUrisStage()`              | [`object-uris.rq`](src/queries/object-uris.rq) — URI object counts                                                 |
+| `createPropertiesStage()`              | [`properties.rq`](src/queries/properties.rq) — Distinct properties                                                 |
+| `createSubjectsStage()`                | [`subjects.rq`](src/queries/subjects.rq) — Distinct subjects                                                       |
+| `createSubjectUriSpaceStage()`         | [`subject-uri-space.rq`](src/queries/subject-uri-space.rq) — Subject URI namespaces                                |
+| `createTriplesStage()`                 | [`triples.rq`](src/queries/triples.rq) — Total triple count                                                        |
+
+### Per-class stages (iterated with a class selector):
+
+| Factory                            | Query                                                                                                                  |
+| ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| `createPerClassDatatypeStage()`    | [`class-property-datatypes.rq`](src/queries/class-property-datatypes.rq) — Per-class datatype partitions               |
+| `createPerClassLanguageStage()`    | [`class-property-languages.rq`](src/queries/class-property-languages.rq) — Per-class language tags                     |
+| `createPerClassObjectClassStage()` | [`class-property-object-classes.rq`](src/queries/class-property-object-classes.rq) — Per-class object class partitions |
 
-- `VocabularyExecutor` — Wraps an executor; detects and appends `void:vocabulary` triples
-- `ProvenanceExecutor` — Wraps an executor; appends PROV-O provenance metadata with automatic timing
+### Domain-specific stages:
 
-## SPARQL Queries
+| Factory                          | Description                                                                                                                           |
+| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
+| `createUriSpaceStage(uriSpaces)` | [`object-uri-space.rq`](src/queries/object-uri-space.rq) — Object URI namespace linksets, aggregated against a provided URI space map |
+| `createVocabularyStage()`        | [`entity-properties.rq`](src/queries/entity-properties.rq) — Entity properties with automatic `void:vocabulary` detection             |
 
-Generic VOiD analysis queries included:
+All factories return `Promise<Stage>`.
+
+## Executor decorators
 
-| Query                              | Description                           |
-| ---------------------------------- | ------------------------------------- |
-| `triples.rq`                       | Total triple count                    |
-| `subjects.rq`                      | Distinct subjects                     |
-| `properties.rq`                    | Distinct properties                   |
-| `class-partition.rq`               | Classes with entity counts            |
-| `class-properties-subjects.rq`     | Properties per class (subject counts) |
-| `class-properties-objects.rq`      | Properties per class (object counts)  |
-| `class-property-datatypes.rq`      | Per-class datatype partitions         |
-| `class-property-languages.rq`      | Per-class language tags               |
-| `class-property-object-classes.rq` | Per-class object class partitions     |
-| `object-literals.rq`               | Literal object counts                 |
-| `object-uris.rq`                   | URI object counts                     |
-| `object-uri-space.rq`              | Object URI namespaces                 |
-| `subject-uri-space.rq`             | Subject URI namespaces                |
-| `datatypes.rq`                     | Dataset-level datatypes               |
-| `entity-properties.rq`             | Property statistics                   |
-| `licenses.rq`                      | License detection                     |
+- `VocabularyExecutor` — Wraps an executor; detects known vocabulary namespace prefixes in `void:property` quads and appends `void:vocabulary` triples.
+- `UriSpaceExecutor` — Wraps an executor; consumes `void:Linkset` quads, matches `void:objectsTarget` against configured URI spaces, and emits aggregated linksets.
 
 ## Usage
 
 ```typescript
 import {
-  createQueryStage,
-  createDatatypeStage,
-  VocabularyExecutor,
-  Stage,
+  createTriplesStage,
+  createClassPartitionStage,
+  createVocabularyStage,
 } from '@lde/pipeline-void';
-import { SparqlConstructExecutor } from '@lde/pipeline';
-
-// Simple CONSTRUCT query stage
-const stage = await createQueryStage('triples.rq');
-await stage.run(dataset, distribution, writer);
-
-// Executor decorator: vocabulary detection wraps entity-properties executor
-const executor = await SparqlConstructExecutor.fromFile(
-  'queries/entity-properties.rq',
-);
-const entityPropertiesStage = new Stage({
-  name: 'entity-properties',
-  executors: new VocabularyExecutor(executor),
-});
-```
-
-## Validation
+import { Pipeline, SparqlUpdateWriter, provenancePlugin } from '@lde/pipeline';
 
-```sh
-npx nx test pipeline-void
-npx nx lint pipeline-void
-npx nx typecheck pipeline-void
+await new Pipeline({
+  datasetSelector: selector,
+  stages: [
+    createTriplesStage(),
+    createClassPartitionStage(),
+    createVocabularyStage(),
+  ],
+  plugins: [provenancePlugin()],
+  writers: new SparqlUpdateWriter({
+    endpoint: new URL('http://localhost:7200/repositories/lde/statements'),
+  }),
+}).run();
 ```

package/dist/index.d.ts

@@ -1,7 +1,5 @@
 export { Stage, NotSupported } from '@lde/pipeline';
-export * from './sparqlQueryAnalyzer.js';
-export * from './perClassAnalyzer.js';
+export * from './stage.js';
 export * from './vocabularyAnalyzer.js';
-export * from './provenance.js';
 export * from './uriSpaceExecutor.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACpD,cAAc,YAAY,CAAC;AAC3B,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC"}

package/dist/index.js

@@ -1,6 +1,4 @@
 export { Stage, NotSupported } from '@lde/pipeline';
-export * from './sparqlQueryAnalyzer.js';
-export * from './perClassAnalyzer.js';
+export * from './stage.js';
 export * from './vocabularyAnalyzer.js';
-export * from './provenance.js';
 export * from './uriSpaceExecutor.js';

package/dist/stage.d.ts

@@ -0,0 +1,19 @@
+import { Stage } from '@lde/pipeline';
+import type { Quad } from '@rdfjs/types';
+export declare function createSubjectUriSpaceStage(): Promise<Stage>;
+export declare function createClassPartitionStage(): Promise<Stage>;
+export declare function createObjectLiteralsStage(): Promise<Stage>;
+export declare function createObjectUrisStage(): Promise<Stage>;
+export declare function createPropertiesStage(): Promise<Stage>;
+export declare function createSubjectsStage(): Promise<Stage>;
+export declare function createTriplesStage(): Promise<Stage>;
+export declare function createClassPropertiesSubjectsStage(): Promise<Stage>;
+export declare function createClassPropertiesObjectsStage(): Promise<Stage>;
+export declare function createDatatypesStage(): Promise<Stage>;
+export declare function createLicensesStage(): Promise<Stage>;
+export declare function createPerClassObjectClassStage(): Promise<Stage>;
+export declare function createPerClassDatatypeStage(): Promise<Stage>;
+export declare function createPerClassLanguageStage(): Promise<Stage>;
+export declare function createUriSpaceStage(uriSpaces: ReadonlyMap<string, readonly Quad[]>): Promise<Stage>;
+export declare function createVocabularyStage(): Promise<Stage>;
+//# sourceMappingURL=stage.d.ts.map

package/dist/stage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage.d.ts","sourceRoot":"","sources":["../src/stage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAMN,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAqDzC,wBAAgB,0BAA0B,IAAI,OAAO,CAAC,KAAK,CAAC,CAE3D;AAED,wBAAgB,yBAAyB,IAAI,OAAO,CAAC,KAAK,CAAC,CAE1D;AAED,wBAAgB,yBAAyB,IAAI,OAAO,CAAC,KAAK,CAAC,CAE1D;AAED,wBAAgB,qBAAqB,IAAI,OAAO,CAAC,KAAK,CAAC,CAEtD;AAED,wBAAgB,qBAAqB,IAAI,OAAO,CAAC,KAAK,CAAC,CAEtD;AAED,wBAAgB,mBAAmB,IAAI,OAAO,CAAC,KAAK,CAAC,CAEpD;AAED,wBAAgB,kBAAkB,IAAI,OAAO,CAAC,KAAK,CAAC,CAEnD;AAED,wBAAgB,kCAAkC,IAAI,OAAO,CAAC,KAAK,CAAC,CAEnE;AAED,wBAAgB,iCAAiC,IAAI,OAAO,CAAC,KAAK,CAAC,CAElE;AAED,wBAAgB,oBAAoB,IAAI,OAAO,CAAC,KAAK,CAAC,CAErD;AAED,wBAAgB,mBAAmB,IAAI,OAAO,CAAC,KAAK,CAAC,CAEpD;AAID,wBAAgB,8BAA8B,IAAI,OAAO,CAAC,KAAK,CAAC,CAI/D;AAED,wBAAgB,2BAA2B,IAAI,OAAO,CAAC,KAAK,CAAC,CAI5D;AAED,wBAAgB,2BAA2B,IAAI,OAAO,CAAC,KAAK,CAAC,CAI5D;AAID,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,GAC9C,OAAO,CAAC,KAAK,CAAC,CAKhB;AAED,wBAAgB,qBAAqB,IAAI,OAAO,CAAC,KAAK,CAAC,CAKtD"}

package/dist/stage.js

@@ -0,0 +1,99 @@
+import { Stage, SparqlConstructExecutor, SparqlItemSelector, readQueryFile, } from '@lde/pipeline';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { VocabularyExecutor } from './vocabularyAnalyzer.js';
+import { UriSpaceExecutor } from './uriSpaceExecutor.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+async function createVoidStage(filename, options) {
+    const query = await readQueryFile(resolve(__dirname, 'queries', filename));
+    const executor = options?.executor?.(query) ?? new SparqlConstructExecutor({ query });
+    if (options?.selection === 'perClass') {
+        return new Stage({
+            name: filename,
+            itemSelector: classSelector(),
+            executors: executor,
+        });
+    }
+    return new Stage({ name: filename, executors: executor });
+}
+function classSelector() {
+    return {
+        select: (distribution) => {
+            const subjectFilter = distribution.subjectFilter ?? '';
+            const fromClause = distribution.namedGraph
+                ? `FROM <${distribution.namedGraph}>`
+                : '';
+            const selectorQuery = [
+                'SELECT DISTINCT ?class',
+                fromClause,
+                `WHERE { ${subjectFilter} ?s a ?class . }`,
+                'LIMIT 1000',
+            ].join('\n');
+            return new SparqlItemSelector({
+                query: selectorQuery,
+                pageSize: 1000,
+            }).select(distribution);
+        },
+    };
+}
+// Global stages
+export function createSubjectUriSpaceStage() {
+    return createVoidStage('subject-uri-space.rq');
+}
+export function createClassPartitionStage() {
+    return createVoidStage('class-partition.rq');
+}
+export function createObjectLiteralsStage() {
+    return createVoidStage('object-literals.rq');
+}
+export function createObjectUrisStage() {
+    return createVoidStage('object-uris.rq');
+}
+export function createPropertiesStage() {
+    return createVoidStage('properties.rq');
+}
+export function createSubjectsStage() {
+    return createVoidStage('subjects.rq');
+}
+export function createTriplesStage() {
+    return createVoidStage('triples.rq');
+}
+export function createClassPropertiesSubjectsStage() {
+    return createVoidStage('class-properties-subjects.rq');
+}
+export function createClassPropertiesObjectsStage() {
+    return createVoidStage('class-properties-objects.rq');
+}
+export function createDatatypesStage() {
+    return createVoidStage('datatypes.rq');
+}
+export function createLicensesStage() {
+    return createVoidStage('licenses.rq');
+}
+// Per-class stages
+export function createPerClassObjectClassStage() {
+    return createVoidStage('class-property-object-classes.rq', {
+        selection: 'perClass',
+    });
+}
+export function createPerClassDatatypeStage() {
+    return createVoidStage('class-property-datatypes.rq', {
+        selection: 'perClass',
+    });
+}
+export function createPerClassLanguageStage() {
+    return createVoidStage('class-property-languages.rq', {
+        selection: 'perClass',
+    });
+}
+// Domain-specific executor stages
+export function createUriSpaceStage(uriSpaces) {
+    return createVoidStage('object-uri-space.rq', {
+        executor: (query) => new UriSpaceExecutor(new SparqlConstructExecutor({ query }), uriSpaces),
+    });
+}
+export function createVocabularyStage() {
+    return createVoidStage('entity-properties.rq', {
+        executor: (query) => new VocabularyExecutor(new SparqlConstructExecutor({ query })),
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/pipeline-void",
-  "version": "0.2.37",
+  "version": "0.3.0",
   "description": "VOiD (Vocabulary of Interlinked Datasets) statistical analysis for RDF datasets",
   "repository": {
     "url": "https://github.com/ldengine/lde",
@@ -21,11 +21,12 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist",
+    "src/queries",
     "!**/*.tsbuildinfo"
   ],
   "dependencies": {
     "@lde/dataset": "0.6.10",
-    "@lde/pipeline": "0.6.32",
+    "@lde/pipeline": "0.7.0",
     "@rdfjs/types": "^2.0.1",
     "@zazuko/prefixes": "^2.6.1",
     "n3": "^1.17.0",

package/src/queries/class-partition.rq

@@ -0,0 +1,19 @@
+PREFIX void: <http://rdfs.org/ns/void#>
+
+CONSTRUCT {
+    ?dataset a void:Dataset ;
+        void:classPartition ?classPartition .
+    ?classPartition void:class ?type ;
+        void:entities ?entities .
+}
+WHERE {
+    {
+        SELECT (COUNT(?type) AS ?entities) ?type {
+            #subjectFilter#
+            ?s a ?type .
+        }
+        GROUP BY ?type
+    }
+    BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-", MD5(STR(?type)))) AS ?classPartition)
+}
+LIMIT 10000

package/src/queries/class-properties-objects.rq

@@ -0,0 +1,17 @@
+PREFIX void: <http://rdfs.org/ns/void#>
+
+CONSTRUCT {
+    ?propertyPartition void:distinctObjects ?objects .
+}
+WHERE {
+    # Object counts only. Subject counts in class-properties-subjects.rq.
+    {
+        SELECT ?type ?p (COUNT(DISTINCT ?o) AS ?objects) {
+            #subjectFilter#
+            ?s a ?type ; ?p ?o .
+        }
+        GROUP BY ?type ?p
+    }
+    BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-property-", MD5(CONCAT(STR(?type), STR(?p))))) AS ?propertyPartition)
+}
+LIMIT 100000

package/src/queries/class-properties-subjects.rq

@@ -0,0 +1,23 @@
+PREFIX void: <http://rdfs.org/ns/void#>
+
+CONSTRUCT {
+    ?dataset a void:Dataset ;
+        void:classPartition ?classPartition .
+    ?classPartition void:class ?type ;
+        void:propertyPartition ?propertyPartition .
+    ?propertyPartition void:property ?p ;
+        void:entities ?subjects .
+}
+WHERE {
+    # Subject counts only. Object counts in class-properties-objects.rq.
+    {
+        SELECT ?type ?p (COUNT(DISTINCT ?s) AS ?subjects) {
+            #subjectFilter#
+            ?s a ?type ; ?p [] .
+        }
+        GROUP BY ?type ?p
+    }
+    BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-", MD5(STR(?type)))) AS ?classPartition)
+    BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-property-", MD5(CONCAT(STR(?type), STR(?p))))) AS ?propertyPartition)
+}
+LIMIT 100000

package/src/queries/class-property-datatypes.rq

@@ -0,0 +1,28 @@
+PREFIX void: <http://rdfs.org/ns/void#>
+PREFIX void-ext: <http://ldf.fi/void-ext#>
+
+CONSTRUCT {
+  ?propertyPartition void-ext:datatypePartition ?datatypePartition .
+  ?datatypePartition
+      void-ext:datatype ?dt ;
+      void:triples ?count .
+}
+WHERE {
+  {
+    SELECT ?p ?dt (COUNT(*) AS ?count) {
+      {
+        SELECT ?p ?o {
+          #subjectFilter#
+          ?s a ?class ;
+            ?p ?o .
+          FILTER (ISLITERAL(?o))
+        }
+      }
+      BIND(DATATYPE(?o) AS ?dt)
+    }
+    GROUP BY ?p ?dt
+  }
+  BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-property-", MD5(CONCAT(STR(?class), STR(?p))))) AS ?propertyPartition)
+  BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#datatype-", MD5(CONCAT(STR(?class), STR(?p), STR(?dt))))) AS ?datatypePartition)
+}
+LIMIT 100000

package/src/queries/class-property-languages.rq

@@ -0,0 +1,30 @@
+PREFIX void: <http://rdfs.org/ns/void#>
+PREFIX void-ext: <http://ldf.fi/void-ext#>
+
+CONSTRUCT {
+  ?propertyPartition void-ext:languagePartition ?languagePartition .
+  ?languagePartition
+    void-ext:language ?lang ;
+    void:triples ?count .
+}
+WHERE {
+  {
+    SELECT ?p ?lang (COUNT(*) AS ?count) {
+      {
+        # Pre-filter to distinct literals to minimize LANG calls
+        SELECT DISTINCT ?p ?o {
+          #subjectFilter#
+          ?s a ?class ;
+            ?p ?o .
+          FILTER(ISLITERAL(?o))
+        }
+      }
+      BIND(LANG(?o) AS ?lang)
+      FILTER(?lang != "")
+    }
+    GROUP BY ?p ?lang
+  }
+  BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-property-", MD5(CONCAT(STR(?class), STR(?p))))) AS ?propertyPartition)
+  BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#language-", MD5(CONCAT(STR(?class), STR(?p), ?lang)))) AS ?languagePartition)
+}
+LIMIT 100000

package/src/queries/class-property-object-classes.rq

@@ -0,0 +1,28 @@
+PREFIX void: <http://rdfs.org/ns/void#>
+PREFIX void-ext: <http://ldf.fi/void-ext#>
+
+CONSTRUCT {
+  ?propertyPartition void-ext:objectClassPartition ?objectClassPartition .
+  ?objectClassPartition
+      void:class ?objectClass ;
+      void:triples ?count .
+}
+WHERE {
+  {
+    SELECT ?p ?objectClass (COUNT(*) AS ?count) {
+      {
+        SELECT ?p ?o {
+          #subjectFilter#
+          ?s a ?class ;
+            ?p ?o .
+          FILTER (ISIRI(?o))
+        }
+      }
+      ?o a ?objectClass .
+    }
+    GROUP BY ?p ?objectClass
+  }
+  BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-property-", MD5(CONCAT(STR(?class), STR(?p))))) AS ?propertyPartition)
+  BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#object-class-", MD5(CONCAT(STR(?class), STR(?p), STR(?objectClass))))) AS ?objectClassPartition)
+}
+LIMIT 100000

package/src/queries/datatypes.rq

@@ -0,0 +1,37 @@
+PREFIX void-ext: <http://ldf.fi/void-ext#>
+
+CONSTRUCT {
+  ?dataset void-ext:datatypes ?count ;
+    void-ext:datatype ?datatype .
+}
+WHERE {
+  {
+    # Count distinct datatypes
+    SELECT (COUNT(DISTINCT ?dt) AS ?count) WHERE {
+      {
+        # Pre-filter to distinct literals to minimize DATATYPE calls
+        SELECT DISTINCT ?o WHERE {
+          #subjectFilter#
+          ?s ?p ?o .
+          FILTER(ISLITERAL(?o))
+        }
+      }
+      BIND(DATATYPE(?o) AS ?dt)
+    }
+  }
+  {
+    # Get distinct datatypes
+    SELECT DISTINCT ?datatype WHERE {
+      {
+        # Pre-filter to distinct literals to minimize DATATYPE calls
+        SELECT DISTINCT ?o WHERE {
+          #subjectFilter#
+          ?s ?p ?o .
+          FILTER(ISLITERAL(?o))
+        }
+      }
+      BIND(DATATYPE(?o) AS ?datatype)
+    }
+  }
+}
+LIMIT 1000

package/src/queries/entity-properties.rq

@@ -0,0 +1,20 @@
+PREFIX void: <http://rdfs.org/ns/void#>
+
+CONSTRUCT {
+    ?dataset a void:Dataset ;
+        void:propertyPartition ?propertyPartition .
+    ?propertyPartition
+        void:property ?p ;
+        void:entities ?subjects ;
+        void:distinctObjects ?objects .
+}
+WHERE {
+    {
+        SELECT (COUNT(DISTINCT ?s) AS ?subjects) (COUNT(DISTINCT ?o) as ?objects) ?p {
+            #subjectFilter#
+            ?s ?p ?o .
+        }
+        GROUP BY ?p
+    }
+    BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#property-partition-", MD5(STR(?p)))) AS ?propertyPartition)
+}

package/src/queries/licenses.rq

@@ -0,0 +1,24 @@
+PREFIX schema: <http://schema.org/>
+PREFIX dcterms: <http://purl.org/dc/terms/>
+PREFIX dc: <http://purl.org/dc/elements/1.1/>
+PREFIX rico: <https://www.ica.org/standards/RiC/ontology#>
+PREFIX void: <http://rdfs.org/ns/void#>
+
+CONSTRUCT {
+    ?dataset a void:Dataset ;
+        void:subset ?licenseSubset .
+    ?licenseSubset
+        dcterms:license ?license ;
+        void:triples ?count .
+}
+WHERE {
+    {
+        SELECT (IRI(?l) AS ?license) (COUNT(*) AS ?count) {
+            #subjectFilter#
+            ?s ?p ?l .
+            VALUES ?p { schema:license <https://schema.org/license> dc:license rico:conditionsOfUse }
+        }
+        GROUP BY ?l
+    }
+    BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#license-", MD5(STR(?license)))) AS ?licenseSubset)
+}

package/src/queries/object-literals.rq

@@ -0,0 +1,14 @@
+PREFIX void: <http://rdfs.org/ns/void#>
+PREFIX void-ext: <http://ldf.fi/void-ext#>
+
+CONSTRUCT {
+    ?dataset a void:Dataset ;
+        void-ext:distinctLiterals ?distinctLiterals .
+}
+WHERE {
+    SELECT (COUNT(DISTINCT ?o) AS ?distinctLiterals) {
+        #subjectFilter#
+        ?s ?p ?o .
+        FILTER(ISLITERAL(?o))
+    }
+}

package/src/queries/object-uri-space.rq

@@ -0,0 +1,25 @@
+PREFIX void: <http://rdfs.org/ns/void#>
+
+CONSTRUCT {
+    ?linkset a void:Linkset ;
+        void:subjectsTarget ?dataset ;
+        void:objectsTarget ?prefix ;
+        void:triples ?count .
+}
+WHERE {
+    {
+        SELECT ?prefix (SUM(?ocount) AS ?count) {
+            {
+                SELECT ?o (COUNT(*) AS ?ocount) {
+                    #subjectFilter#
+                    ?s ?p ?o .
+                    FILTER(ISIRI(?o))
+                }
+                GROUP BY ?o
+            }
+            BIND(REPLACE(STR(?o), "([^/]+$)", "") AS ?prefix)
+        }
+        GROUP BY ?prefix ORDER BY DESC(?count) LIMIT 1000
+    }
+    BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#linkset-", MD5(CONCAT(STR(?dataset), ?prefix)))) AS ?linkset)
+}

package/src/queries/object-uris.rq

@@ -0,0 +1,14 @@
+PREFIX void: <http://rdfs.org/ns/void#>
+PREFIX void-ext: <http://ldf.fi/void-ext#>
+
+CONSTRUCT {
+    ?dataset a void:Dataset ;
+        void-ext:distinctIRIReferenceObjects ?distinctIRIReferenceObjects .
+}
+WHERE {
+    SELECT (COUNT(DISTINCT ?o) AS ?distinctIRIReferenceObjects) {
+        #subjectFilter#
+        ?s ?p ?o .
+        FILTER(ISIRI(?o))
+    }
+}

package/src/queries/properties.rq

@@ -0,0 +1,12 @@
+PREFIX void: <http://rdfs.org/ns/void#>
+
+CONSTRUCT {
+    ?dataset a void:Dataset ;
+        void:properties ?count .
+}
+WHERE {
+    SELECT (COUNT(DISTINCT ?p) as ?count) {
+        #subjectFilter#
+        ?s ?p ?o
+    }
+}

package/src/queries/subject-uri-space.rq

@@ -0,0 +1,30 @@
+PREFIX void: <http://rdfs.org/ns/void#>
+
+CONSTRUCT {
+    ?dataset a void:Dataset ;
+        void:subset ?subset .
+    ?subset void:uriSpace ?uriSpace ;
+        void:entities ?count .
+}
+WHERE {
+    {
+        # Pre-group distinct subjects before computing namespace to avoid regex on every triple.
+        SELECT ?uriSpace (COUNT(*) AS ?count) {
+            {
+                SELECT DISTINCT ?s {
+                    #subjectFilter#
+                    ?s ?p ?o .
+                    FILTER(ISIRI(?s))
+                }
+            }
+            # Extract namespace by removing the local name (everything after the last / or #)
+            BIND(REPLACE(STR(?s), "[^/#]+$", "") AS ?uriSpace)
+        }
+        GROUP BY ?uriSpace
+        ORDER BY DESC(?count)
+        LIMIT 10
+    }
+    FILTER(?count > 1)  # Only include namespaces with more than 1 entity
+    BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#subject-uri-space-", MD5(?uriSpace))) AS ?subset)
+}
+

package/src/queries/subjects.rq

@@ -0,0 +1,13 @@
+PREFIX void: <http://rdfs.org/ns/void#>
+
+CONSTRUCT {
+    ?dataset a void:Dataset ;
+        void:distinctSubjects ?count .
+}
+WHERE {
+    SELECT (COUNT(DISTINCT ?s) as ?count) {
+        #subjectFilter#
+        ?s ?p ?o .
+        FILTER(!ISBLANK(?s))
+    }
+}

package/src/queries/triples.rq

@@ -0,0 +1,12 @@
+PREFIX void: <http://rdfs.org/ns/void#>
+
+CONSTRUCT {
+    ?dataset a void:Dataset ;
+        void:triples ?count .
+}
+WHERE {
+    SELECT (COUNT(*) as ?count) {
+        #subjectFilter#
+        ?s ?p ?o
+    }
+}

package/dist/perClassAnalyzer.d.ts

@@ -1,5 +0,0 @@
-import { Stage } from '@lde/pipeline';
-export declare function createDatatypeStage(): Promise<Stage>;
-export declare function createLanguageStage(): Promise<Stage>;
-export declare function createObjectClassStage(): Promise<Stage>;
-//# sourceMappingURL=perClassAnalyzer.d.ts.map

package/dist/perClassAnalyzer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"perClassAnalyzer.d.ts","sourceRoot":"","sources":["../src/perClassAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAKN,MAAM,eAAe,CAAC;AA4CvB,wBAAgB,mBAAmB,IAAI,OAAO,CAAC,KAAK,CAAC,CAEpD;AAED,wBAAgB,mBAAmB,IAAI,OAAO,CAAC,KAAK,CAAC,CAEpD;AAED,wBAAgB,sBAAsB,IAAI,OAAO,CAAC,KAAK,CAAC,CAEvD"}

package/dist/perClassAnalyzer.js

@@ -1,44 +0,0 @@
-import { Stage, SparqlItemSelector, SparqlConstructExecutor, readQueryFile, } from '@lde/pipeline';
-import { resolve, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-/**
- * Create a Stage that first selects classes from the endpoint,
- * then runs a per-class CONSTRUCT query with `?class` bound via VALUES.
- */
-async function createPerClassStage(queryFilename) {
-    const rawQuery = await readQueryFile(resolve(__dirname, 'queries', queryFilename));
-    const executor = new SparqlConstructExecutor({ query: rawQuery });
-    const itemSelector = {
-        select: (distribution) => {
-            const subjectFilter = distribution.subjectFilter ?? '';
-            const fromClause = distribution.namedGraph
-                ? `FROM <${distribution.namedGraph}>`
-                : '';
-            const selectorQuery = [
-                'SELECT DISTINCT ?class',
-                fromClause,
-                `WHERE { ${subjectFilter} ?s a ?class . }`,
-                'LIMIT 1000',
-            ].join('\n');
-            return new SparqlItemSelector({
-                query: selectorQuery,
-                pageSize: 1000,
-            }).select(distribution);
-        },
-    };
-    return new Stage({
-        name: queryFilename,
-        itemSelector,
-        executors: executor,
-    });
-}
-export function createDatatypeStage() {
-    return createPerClassStage('class-property-datatypes.rq');
-}
-export function createLanguageStage() {
-    return createPerClassStage('class-property-languages.rq');
-}
-export function createObjectClassStage() {
-    return createPerClassStage('class-property-object-classes.rq');
-}

package/dist/provenance.d.ts

@@ -1,23 +0,0 @@
-import { Dataset, Distribution } from '@lde/dataset';
-import { NotSupported, type Executor, type ExecuteOptions } from '@lde/pipeline';
-import type { Quad } from '@rdfjs/types';
-/**
- * Executor decorator that passes through all quads from the inner executor
- * and appends PROV-O provenance metadata.
- *
- * Timestamps are captured automatically: `startedAt` when `execute()` is
- * called, `endedAt` when the inner quad stream is fully consumed.
- *
- * Appended quads:
- * - `<dataset> a prov:Entity`
- * - `<dataset> prov:wasGeneratedBy _:activity`
- * - `_:activity a prov:Activity`
- * - `_:activity prov:startedAtTime "..."^^xsd:dateTime`
- * - `_:activity prov:endedAtTime "..."^^xsd:dateTime`
- */
-export declare class ProvenanceExecutor implements Executor {
-    private readonly inner;
-    constructor(inner: Executor);
-    execute(dataset: Dataset, distribution: Distribution, options?: ExecuteOptions): Promise<AsyncIterable<Quad> | NotSupported>;
-}
-//# sourceMappingURL=provenance.d.ts.map

package/dist/provenance.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"provenance.d.ts","sourceRoot":"","sources":["../src/provenance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EACL,YAAY,EACZ,KAAK,QAAQ,EACb,KAAK,cAAc,EACpB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAiBzC;;;;;;;;;;;;;GAaG;AACH,qBAAa,kBAAmB,YAAW,QAAQ;IACrC,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAAL,KAAK,EAAE,QAAQ;IAEtC,OAAO,CACX,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,YAAY,EAC1B,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,YAAY,CAAC;CAQ/C"}

package/dist/provenance.js

@@ -1,51 +0,0 @@
-import { NotSupported, } from '@lde/pipeline';
-import { DataFactory } from 'n3';
-const { namedNode, literal, blankNode, quad } = DataFactory;
-const RDF_TYPE = namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
-const PROV_ENTITY = namedNode('http://www.w3.org/ns/prov#Entity');
-const PROV_ACTIVITY = namedNode('http://www.w3.org/ns/prov#Activity');
-const PROV_WAS_GENERATED_BY = namedNode('http://www.w3.org/ns/prov#wasGeneratedBy');
-const PROV_STARTED_AT_TIME = namedNode('http://www.w3.org/ns/prov#startedAtTime');
-const PROV_ENDED_AT_TIME = namedNode('http://www.w3.org/ns/prov#endedAtTime');
-const XSD_DATE_TIME = namedNode('http://www.w3.org/2001/XMLSchema#dateTime');
-/**
- * Executor decorator that passes through all quads from the inner executor
- * and appends PROV-O provenance metadata.
- *
- * Timestamps are captured automatically: `startedAt` when `execute()` is
- * called, `endedAt` when the inner quad stream is fully consumed.
- *
- * Appended quads:
- * - `<dataset> a prov:Entity`
- * - `<dataset> prov:wasGeneratedBy _:activity`
- * - `_:activity a prov:Activity`
- * - `_:activity prov:startedAtTime "..."^^xsd:dateTime`
- * - `_:activity prov:endedAtTime "..."^^xsd:dateTime`
- */
-export class ProvenanceExecutor {
-    inner;
-    constructor(inner) {
-        this.inner = inner;
-    }
-    async execute(dataset, distribution, options) {
-        const startedAt = new Date();
-        const result = await this.inner.execute(dataset, distribution, options);
-        if (result instanceof NotSupported) {
-            return result;
-        }
-        return withProvenance(result, dataset.iri.toString(), startedAt);
-    }
-}
-async function* withProvenance(quads, iri, startedAt) {
-    for await (const q of quads) {
-        yield q;
-    }
-    const endedAt = new Date();
-    const subject = namedNode(iri);
-    const activity = blankNode();
-    yield quad(subject, RDF_TYPE, PROV_ENTITY);
-    yield quad(subject, PROV_WAS_GENERATED_BY, activity);
-    yield quad(activity, RDF_TYPE, PROV_ACTIVITY);
-    yield quad(activity, PROV_STARTED_AT_TIME, literal(startedAt.toISOString(), XSD_DATE_TIME));
-    yield quad(activity, PROV_ENDED_AT_TIME, literal(endedAt.toISOString(), XSD_DATE_TIME));
-}

package/dist/sparqlQueryAnalyzer.d.ts

@@ -1,9 +0,0 @@
-import { Stage } from '@lde/pipeline';
-/**
- * Create a Stage that executes a SPARQL CONSTRUCT query from the queries directory.
- *
- * `#subjectFilter#` is handled at runtime by the executor;
- * `?dataset` and `FROM <graph>` are handled at the AST level by the executor.
- */
-export declare function createQueryStage(filename: string): Promise<Stage>;
-//# sourceMappingURL=sparqlQueryAnalyzer.d.ts.map

package/dist/sparqlQueryAnalyzer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sparqlQueryAnalyzer.d.ts","sourceRoot":"","sources":["../src/sparqlQueryAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAA0C,MAAM,eAAe,CAAC;AAM9E;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAKvE"}

package/dist/sparqlQueryAnalyzer.js

@@ -1,15 +0,0 @@
-import { Stage, SparqlConstructExecutor, readQueryFile } from '@lde/pipeline';
-import { resolve, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-/**
- * Create a Stage that executes a SPARQL CONSTRUCT query from the queries directory.
- *
- * `#subjectFilter#` is handled at runtime by the executor;
- * `?dataset` and `FROM <graph>` are handled at the AST level by the executor.
- */
-export async function createQueryStage(filename) {
-    const rawQuery = await readQueryFile(resolve(__dirname, 'queries', filename));
-    const executor = new SparqlConstructExecutor({ query: rawQuery });
-    return new Stage({ name: filename, executors: executor });
-}