diff --git a/docs/api/rest-api.md b/docs/api/rest-api.md
index 8345ae99c..401137798 100644
--- a/docs/api/rest-api.md
+++ b/docs/api/rest-api.md
@@ -48,6 +48,7 @@ Read, change, and validate Subjects. New Subjects are created on a page — see
| Endpoint | Description |
|---|---|
| `GET /neowiki/v0/subject/{subjectId}` | Fetch a Subject. Optional `revisionId`; `expand` with `page` or `relations`. |
+| `GET /neowiki/v0/subject/{subjectId}/rdf` | Export one Subject as RDF. `format` is `trig` (default) or `turtle`; `projection` is `native` (default) or an ontology target. See [RDF export](../rdf/rdf-export.md). |
| `PUT /neowiki/v0/subject/{subjectId}` | Replace a Subject's label and statements. |
| `DELETE /neowiki/v0/subject/{subjectId}` | Delete a Subject. |
| `POST /neowiki/v0/subject/validate` | Check whether a new Subject is valid, without saving it. |
diff --git a/docs/rdf/rdf-export.md b/docs/rdf/rdf-export.md
index 6216c31b2..241c4792e 100644
--- a/docs/rdf/rdf-export.md
+++ b/docs/rdf/rdf-export.md
@@ -64,26 +64,51 @@ describe the same set of entities. A warning is logged for each omitted Subject.
## Endpoint
-`GET /rest.php/neowiki/v0/page/{pageId}/rdf`
-
-Returns the page's projection. The `projection` query parameter selects the vocabulary: `native` (the
-default, described here) or the name of a Mapping page — see
-[Ontology Mapping](ontology-mapping.md). An unknown projection returns `400`.
-
-The format is chosen by the `format` query parameter, falling back to the `Accept` header, then to
-TriG:
+RDF is served per page or per Subject. Both take the same `projection` and `format` query parameters.
+The `projection` selects the vocabulary: `native` (the default, described here) or the name of a
+Mapping page — see [Ontology Mapping](ontology-mapping.md); an unknown projection returns `400`. The
+`format` picks the serialization, falling back to the `Accept` header, then to TriG:
| `format` | `Accept` | Content-Type | Named graph |
|---|---|---|---|
| `trig` (default) | `application/trig` | `application/trig; charset=utf-8` | yes |
| `turtle` | `text/turtle` | `text/turtle; charset=utf-8` | no (same triples, no graph wrapper) |
+### Page
+
+`GET /rest.php/neowiki/v0/page/{pageId}/rdf`
+
+Returns the page's projection: its page metadata and every Subject on it, in the page's named graph.
Returns `404` when the page does not exist or has no NeoWiki Subject data.
```sh
curl 'https://wiki.example/rest.php/neowiki/v0/page/42/rdf?format=turtle'
```
+### Subject
+
+`GET /rest.php/neowiki/v0/subject/{subjectId}/rdf`
+
+Returns one Subject's projection: exactly the triples the page export emits for that Subject — its
+outbound description, including the native relation reification — with none of the page-metadata
+triples, in the hosting page's named graph. Inbound relations pointing at the Subject from elsewhere
+are not included.
+
+Returns `404` when the Subject does not exist or is on a page the caller may not read — the two are
+indistinguishable. A malformed Subject ID returns `400`. A readable Subject whose Schema has no mapping
+for the requested ontology target projects to an empty graph — a `200`, not a `404`.
+
+```sh
+curl 'https://wiki.example/rest.php/neowiki/v0/subject/s1demo8aaaaaab5/rdf?projection=EDM'
+```
+
+### Finding these exports
+
+These exports are surfaced in the UI: the Data tab (`?action=subjects`) links to each Subject's JSON and
+per-projection Turtle/TriG, and to the same for the whole page. Pages that carry NeoWiki data also
+advertise the page export through `
-
+
+
+
+
+
+
@@ -320,6 +343,16 @@
+
@@ -386,6 +419,7 @@ import type { MenuButtonItemData } from '@wikimedia/codex';
import {
cdxIconAdd,
cdxIconCollapse,
+ cdxIconDownload,
cdxIconDraggable,
cdxIconEdit,
cdxIconEllipsis,
@@ -406,9 +440,14 @@ import EditSummary from '@/components/common/EditSummary.vue';
import I18nSlot from '@/components/common/I18nSlot.vue';
import SubjectStatementsView from '@/components/SubjectsManager/SubjectStatementsView.vue';
import { setPendingNotification } from '@/presentation/PendingNotification.ts';
+import { subjectExportMenuItems, pageExportMenuItems } from '@/presentation/DataExportMenu.ts';
const pageId = Number( mw.config.get( 'wgNeoWikiManageSubjectsPageId' ) );
+// RDF projections readable by the viewing user (native + ontology mappings), permission-filtered
+// server-side. Drives the export menus; native is always present, so this is never truly empty.
+const rdfProjections = ( mw.config.get( 'wgNeoWikiRdfProjections' ) as string[] | null ) ?? [];
+
const subjectStore = useSubjectStore();
const schemaStore = useSchemaStore();
const {
@@ -553,6 +592,26 @@ function dispatchRowAction( value: string | number | null, subject: Subject ): v
}
}
+const exportMenuSelection = ref( null );
+
+function subjectExportItems( subject: Subject ): MenuButtonItemData[] {
+ return subjectExportMenuItems( subject.getId().text, rdfProjections );
+}
+
+const pageExportItems = computed(
+ () => pageExportMenuItems( pageId, rdfProjections )
+);
+
+// The menu item value is the export endpoint URL; open it in a new tab so the Data tab UI state
+// (expanded rows, edits in progress) survives. Codex 1.14 menu-item anchors cannot set a target,
+// so we navigate on selection rather than rely on the item's `url`.
+function openExport( value: string | number | null ): void {
+ exportMenuSelection.value = null;
+ if ( typeof value === 'string' && value !== '' ) {
+ window.open( value, '_blank', 'noopener' );
+ }
+}
+
function toggleExpanded( id: string ): void {
const next = new Set( expandedIds.value );
if ( next.has( id ) ) {
@@ -799,6 +858,12 @@ onUnmounted( () => {
margin-bottom: @spacing-150;
}
+ &__controls-actions {
+ display: flex;
+ align-items: center;
+ gap: @spacing-100;
+ }
+
&__count {
color: @color-subtle;
}
@@ -1104,7 +1169,9 @@ onUnmounted( () => {
&__row-footer {
display: flex;
- justify-content: flex-start;
+ flex-wrap: wrap;
+ align-items: center;
+ justify-content: space-between;
gap: @spacing-100;
margin-top: @spacing-100;
padding-top: @spacing-75;
diff --git a/resources/ext.neowiki/src/presentation/DataExportMenu.ts b/resources/ext.neowiki/src/presentation/DataExportMenu.ts
new file mode 100644
index 000000000..73f8b15e4
--- /dev/null
+++ b/resources/ext.neowiki/src/presentation/DataExportMenu.ts
@@ -0,0 +1,67 @@
+import type { MenuButtonItemData } from '@wikimedia/codex';
+
+/**
+ * Builds the export menu items for the Data tab: a JSON entry, then Turtle and TriG entries for each
+ * RDF projection the viewing user may read (native first, then ontology mappings). Item values are the
+ * full endpoint URLs; the menu navigates to them on selection. Kept as pure functions so the URL and
+ * label derivation is unit-tested independently of the Vue component.
+ */
+
+interface RdfFormatOption {
+ format: string;
+ messageKey: string;
+}
+
+const RDF_FORMATS: readonly RdfFormatOption[] = [
+ { format: 'turtle', messageKey: 'neowiki-managesubjects-export-turtle' },
+ { format: 'trig', messageKey: 'neowiki-managesubjects-export-trig' },
+];
+
+const NATIVE_PROJECTION = 'native';
+
+function restApiBase(): string {
+ return mw.util.wikiScript( 'rest' );
+}
+
+function projectionLabel( projection: string ): string {
+ return projection === NATIVE_PROJECTION ?
+ mw.msg( 'neowiki-managesubjects-export-native' ) :
+ projection;
+}
+
+function exportMenuItems(
+ jsonUrl: string,
+ rdfEndpoint: string,
+ projections: readonly string[],
+): MenuButtonItemData[] {
+ const items: MenuButtonItemData[] = [
+ { value: jsonUrl, label: mw.msg( 'neowiki-managesubjects-export-json' ) },
+ ];
+
+ for ( const projection of projections ) {
+ for ( const { format, messageKey } of RDF_FORMATS ) {
+ items.push( {
+ value: `${ rdfEndpoint }?projection=${ encodeURIComponent( projection ) }&format=${ format }`,
+ label: mw.msg( messageKey, projectionLabel( projection ) ),
+ } );
+ }
+ }
+
+ return items;
+}
+
+export function subjectExportMenuItems(
+ subjectId: string,
+ projections: readonly string[],
+): MenuButtonItemData[] {
+ const base = `${ restApiBase() }/neowiki/v0/subject/${ encodeURIComponent( subjectId ) }`;
+ return exportMenuItems( base, `${ base }/rdf`, projections );
+}
+
+export function pageExportMenuItems(
+ pageId: number,
+ projections: readonly string[],
+): MenuButtonItemData[] {
+ const base = `${ restApiBase() }/neowiki/v0/page/${ pageId }`;
+ return exportMenuItems( `${ base }/subjects`, `${ base }/rdf`, projections );
+}
diff --git a/resources/ext.neowiki/tests/presentation/DataExportMenu.spec.ts b/resources/ext.neowiki/tests/presentation/DataExportMenu.spec.ts
new file mode 100644
index 000000000..1e5c5c6b1
--- /dev/null
+++ b/resources/ext.neowiki/tests/presentation/DataExportMenu.spec.ts
@@ -0,0 +1,67 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { subjectExportMenuItems, pageExportMenuItems } from '@/presentation/DataExportMenu';
+
+describe( 'DataExportMenu', () => {
+ beforeEach( () => {
+ vi.stubGlobal( 'mw', {
+ util: { wikiScript: vi.fn( () => '/w/rest.php' ) },
+ msg: vi.fn( ( key: string, ...params: string[] ) =>
+ params.length > 0 ? `[${ key }|${ params.join( ',' ) }]` : `[${ key }]` ),
+ } );
+ } );
+
+ describe( 'subjectExportMenuItems', () => {
+ it( 'lists JSON first, then Turtle and TriG for each projection in order', () => {
+ const items = subjectExportMenuItems( 's2picasso2aaaa2', [ 'native', 'EDM' ] );
+
+ expect( items.map( ( item ) => item.value ) ).toEqual( [
+ '/w/rest.php/neowiki/v0/subject/s2picasso2aaaa2',
+ '/w/rest.php/neowiki/v0/subject/s2picasso2aaaa2/rdf?projection=native&format=turtle',
+ '/w/rest.php/neowiki/v0/subject/s2picasso2aaaa2/rdf?projection=native&format=trig',
+ '/w/rest.php/neowiki/v0/subject/s2picasso2aaaa2/rdf?projection=EDM&format=turtle',
+ '/w/rest.php/neowiki/v0/subject/s2picasso2aaaa2/rdf?projection=EDM&format=trig',
+ ] );
+ } );
+
+ it( 'labels JSON, the native projection, and mapping projections distinctly', () => {
+ const items = subjectExportMenuItems( 's2picasso2aaaa2', [ 'native', 'EDM' ] );
+
+ expect( items.map( ( item ) => item.label ) ).toEqual( [
+ '[neowiki-managesubjects-export-json]',
+ '[neowiki-managesubjects-export-turtle|[neowiki-managesubjects-export-native]]',
+ '[neowiki-managesubjects-export-trig|[neowiki-managesubjects-export-native]]',
+ '[neowiki-managesubjects-export-turtle|EDM]',
+ '[neowiki-managesubjects-export-trig|EDM]',
+ ] );
+ } );
+
+ it( 'percent-encodes the projection name in the RDF URLs', () => {
+ const items = subjectExportMenuItems( 's1aaaaaaaaaaaa1', [ 'Wikidata items' ] );
+
+ expect( items[ 1 ].value ).toBe(
+ '/w/rest.php/neowiki/v0/subject/s1aaaaaaaaaaaa1/rdf?projection=Wikidata%20items&format=turtle',
+ );
+ } );
+
+ it( 'returns only the JSON entry when there are no readable projections', () => {
+ const items = subjectExportMenuItems( 's1aaaaaaaaaaaa1', [] );
+
+ expect( items ).toHaveLength( 1 );
+ expect( items[ 0 ].value ).toBe( '/w/rest.php/neowiki/v0/subject/s1aaaaaaaaaaaa1' );
+ } );
+ } );
+
+ describe( 'pageExportMenuItems', () => {
+ it( 'targets the page subjects JSON and the page RDF endpoint', () => {
+ const items = pageExportMenuItems( 42, [ 'native', 'EDM' ] );
+
+ expect( items.map( ( item ) => item.value ) ).toEqual( [
+ '/w/rest.php/neowiki/v0/page/42/subjects',
+ '/w/rest.php/neowiki/v0/page/42/rdf?projection=native&format=turtle',
+ '/w/rest.php/neowiki/v0/page/42/rdf?projection=native&format=trig',
+ '/w/rest.php/neowiki/v0/page/42/rdf?projection=EDM&format=turtle',
+ '/w/rest.php/neowiki/v0/page/42/rdf?projection=EDM&format=trig',
+ ] );
+ } );
+ } );
+} );
diff --git a/src/Application/Rdf/OntologyMappingProjector.php b/src/Application/Rdf/OntologyMappingProjector.php
index a98f2605a..38eaf1e5c 100644
--- a/src/Application/Rdf/OntologyMappingProjector.php
+++ b/src/Application/Rdf/OntologyMappingProjector.php
@@ -19,6 +19,7 @@
use ProfessionalWiki\NeoWiki\Domain\Rdf\RdfValueMapperRegistry;
use ProfessionalWiki\NeoWiki\Domain\Statement;
use ProfessionalWiki\NeoWiki\Domain\Subject\Subject;
+use ProfessionalWiki\NeoWiki\Domain\Subject\SubjectId;
use ProfessionalWiki\NeoWiki\Domain\Value\RelationValue;
use Psr\Log\LoggerInterface;
@@ -60,17 +61,41 @@ public function projectPage( Page $page ): QuadList {
$schemaMapping = $this->mapping->forSchema( $subject->getSchemaName() );
if ( $schemaMapping !== null ) {
- $quads = array_merge( $quads, $this->projectSubject( $subject, $schemaMapping, $graph ) );
+ $quads = array_merge( $quads, $this->subjectQuads( $subject, $schemaMapping, $graph ) );
}
}
return QuadList::fromArray( $quads );
}
+ /**
+ * Projects a single Subject on the page into the target ontology — its per-Subject block from
+ * {@see projectPage()} (mapped type, label, mapped property values, relations as direct triples)
+ * placed in the target's named graph. A Subject that is not on the page, or whose Schema has no
+ * entry in this Mapping, yields an empty list.
+ */
+ public function projectSubject( Page $page, SubjectId $subjectId ): QuadList {
+ $subject = $page->getSubjects()->getAllSubjects()->getSubject( $subjectId );
+
+ if ( $subject === null ) {
+ return new QuadList();
+ }
+
+ $schemaMapping = $this->mapping->forSchema( $subject->getSchemaName() );
+
+ if ( $schemaMapping === null ) {
+ return new QuadList();
+ }
+
+ return QuadList::fromArray(
+ $this->subjectQuads( $subject, $schemaMapping, $this->namespaces->graph( $this->target, $page->getId() ) )
+ );
+ }
+
/**
* @return Quad[]
*/
- private function projectSubject( Subject $subject, SchemaMapping $schemaMapping, Iri $graph ): array {
+ private function subjectQuads( Subject $subject, SchemaMapping $schemaMapping, Iri $graph ): array {
$subjectIri = $this->namespaces->subject( $subject->id );
$quads = [
diff --git a/src/Application/Rdf/PageProjector.php b/src/Application/Rdf/PageProjector.php
index d0e2ed11c..1b5405ffc 100644
--- a/src/Application/Rdf/PageProjector.php
+++ b/src/Application/Rdf/PageProjector.php
@@ -6,6 +6,7 @@
use ProfessionalWiki\NeoWiki\Domain\Page\Page;
use ProfessionalWiki\NeoWiki\Domain\Rdf\QuadList;
+use ProfessionalWiki\NeoWiki\Domain\Subject\SubjectId;
/**
* Projects a {@see Page} to RDF quads in some target vocabulary. The native projection
@@ -17,4 +18,14 @@ interface PageProjector {
public function projectPage( Page $page ): QuadList;
+ /**
+ * Projects the single Subject $subjectId hosted on $page: exactly the quads {@see projectPage()}
+ * emits for that Subject (its outbound bounded description, including native relation reification),
+ * with none of the page-metadata quads. The page is passed for context — the graph IRI derives from
+ * its id and the Schema/Mapping is resolved as in a full-page projection. Returns an empty list when
+ * the Subject is absent from the page or its projection yields no quads (native: the Schema is
+ * unavailable; ontology: no Mapping targets it).
+ */
+ public function projectSubject( Page $page, SubjectId $subjectId ): QuadList;
+
}
diff --git a/src/Application/Rdf/RdfPageProjector.php b/src/Application/Rdf/RdfPageProjector.php
index 45a19530a..c295ec8b2 100644
--- a/src/Application/Rdf/RdfPageProjector.php
+++ b/src/Application/Rdf/RdfPageProjector.php
@@ -21,6 +21,7 @@
use ProfessionalWiki\NeoWiki\Domain\Schema\Schema;
use ProfessionalWiki\NeoWiki\Domain\Statement;
use ProfessionalWiki\NeoWiki\Domain\Subject\Subject;
+use ProfessionalWiki\NeoWiki\Domain\Subject\SubjectId;
use Psr\Log\LoggerInterface;
/**
@@ -68,12 +69,37 @@ public function projectPage( Page $page ): QuadList {
$quads = $this->projectPageMetadata( $page, $subjects, $graph );
foreach ( $subjects as [ $subject, $schema ] ) {
- $quads = array_merge( $quads, $this->projectSubject( $subject, $schema, $graph, $page->getId() ) );
+ $quads = array_merge( $quads, $this->subjectQuads( $subject, $schema, $graph, $page->getId() ) );
}
return QuadList::fromArray( $quads );
}
+ /**
+ * Projects a single Subject on the page — its per-Subject block from {@see projectPage()} (type,
+ * label, Statements, reified Relations) placed in the page's native named graph, without any
+ * page-metadata quads. A Subject that is not on the page, or whose Schema is unavailable (logged,
+ * as in the full-page projection), yields an empty list.
+ */
+ public function projectSubject( Page $page, SubjectId $subjectId ): QuadList {
+ $subject = $page->getSubjects()->getAllSubjects()->getSubject( $subjectId );
+
+ if ( $subject === null ) {
+ return new QuadList();
+ }
+
+ $schema = $this->schemaLookup->getSchema( $subject->getSchemaName() );
+
+ if ( $schema === null ) {
+ $this->logger->warning( 'Schema not found: ' . $subject->getSchemaName()->getText() );
+ return new QuadList();
+ }
+
+ return QuadList::fromArray(
+ $this->subjectQuads( $subject, $schema, $this->namespaces->graph( self::PROJECTION, $page->getId() ), $page->getId() )
+ );
+ }
+
/**
* Resolves each Subject's Schema up front. A Subject whose Schema is unavailable is dropped from
* the projection entirely — matching Neo4jSubjectUpdater, which skips the whole Subject — so page
@@ -168,7 +194,7 @@ private function isProjected( Subject $mainSubject, array $subjects ): bool {
/**
* @return Quad[]
*/
- private function projectSubject( Subject $subject, Schema $schema, Iri $graph, PageId $pageId ): array {
+ private function subjectQuads( Subject $subject, Schema $schema, Iri $graph, PageId $pageId ): array {
$subjectIri = $this->namespaces->subject( $subject->id );
$quads = [
diff --git a/src/Application/Rdf/RdfSubjectExporter.php b/src/Application/Rdf/RdfSubjectExporter.php
new file mode 100644
index 000000000..85184d1df
--- /dev/null
+++ b/src/Application/Rdf/RdfSubjectExporter.php
@@ -0,0 +1,57 @@
+pageIdentifiersLookup->getPageIdOfSubject( $subjectId );
+
+ if ( $pageIdentifiers === null ) {
+ return null;
+ }
+
+ if ( !$this->readAuthorizer->authorizeReadByPageId( $pageIdentifiers->getId() ) ) {
+ return null;
+ }
+
+ $page = $this->loader->loadByPageId( $pageIdentifiers->getId() );
+
+ if ( $page === null || $page->getSubjects()->getAllSubjects()->getSubject( $subjectId ) === null ) {
+ return null;
+ }
+
+ return $this->serializer->serialize( $this->projector->projectSubject( $page, $subjectId ), $format );
+ }
+
+}
diff --git a/src/EntryPoints/Actions/SubjectsAction.php b/src/EntryPoints/Actions/SubjectsAction.php
index 0e1cf03d8..b23277619 100644
--- a/src/EntryPoints/Actions/SubjectsAction.php
+++ b/src/EntryPoints/Actions/SubjectsAction.php
@@ -45,10 +45,17 @@ public function onView(): string {
);
}
- NeoWikiExtension::getInstance()->newFrontendModuleLoader()->load( $out, $this->getSkin() );
+ $extension = NeoWikiExtension::getInstance();
+ $extension->newFrontendModuleLoader()->load( $out, $this->getSkin() );
$out->addJsConfigVars( [
'wgNeoWikiManageSubjectsPageId' => $title->getArticleID(),
+ // The export UI (Data tab menus) is driven by this list. Filtered by the viewing user's
+ // read authority so restricted Mapping page titles never reach a reader who cannot see them.
+ 'wgNeoWikiRdfProjections' => $extension->filterReadableProjectionNames(
+ $extension->getRdfProjectionNames(),
+ $this->getAuthority()
+ ),
] );
return Html::element( 'div', [ 'id' => 'ext-neowiki-manage-subjects' ] );
diff --git a/src/EntryPoints/NeoWikiHooks.php b/src/EntryPoints/NeoWikiHooks.php
index 36a6b7037..9d8f19e7c 100644
--- a/src/EntryPoints/NeoWikiHooks.php
+++ b/src/EntryPoints/NeoWikiHooks.php
@@ -6,6 +6,7 @@
use MediaWiki\Html\Html;
use MediaWiki\Logger\LoggerFactory;
+use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Output\OutputPage;
use MediaWiki\Page\ProperPageIdentity;
@@ -16,6 +17,7 @@
use MediaWiki\Title\ForeignTitle;
use MediaWiki\Title\Title;
use MediaWiki\User\UserIdentity;
+use ProfessionalWiki\NeoWiki\Application\Rdf\RdfPageProjector;
use ProfessionalWiki\NeoWiki\Domain\Page\PageId;
use ProfessionalWiki\NeoWiki\EntryPoints\Content\SchemaContent;
use ProfessionalWiki\NeoWiki\EntryPoints\Content\SubjectContent;
@@ -61,6 +63,7 @@ private static function handleContentPage( OutputPage $out, Skin $skin ): void {
NeoWikiExtension::getInstance()->newFrontendModuleLoader()->load( $out, $skin );
$out->addHtml( self::getNeoWikiAppHtml( $out ) );
+ self::addRdfAutodiscoveryLinks( $out );
if ( !NeoWikiExtension::getInstance()->shouldAutoRenderMainSubject() ) {
return;
@@ -113,6 +116,34 @@ private static function pageIsLatestRevision( OutputPage $out ): bool {
return $out->getRevisionId() === $out->getTitle()->getLatestRevID();
}
+ /**
+ * Advertises the page's RDF export (native projection) via ` .
+ @prefix rdfs: .
+ @prefix xsd: .
+ @prefix edm: .
+
+ neo-graph:42 {
+ neo-subj:s1acmeaaaaaaaa1 a neo-schema:Company ;
+ rdfs:label "ACME Corp" ;
+ neo-prop:Founded 2019 ;
+ neo-prop:CEO neo-subj:s1janeaaaaaaaa2 .
+
+ neo-rel:r1ceoaaaaaaaaa3 a neo:Relation ;
+ neo:source neo-subj:s1acmeaaaaaaaa1 ;
+ neo:target neo-subj:s1janeaaaaaaaa2 ;
+ neo:relationType neo-prop:CEO ;
+ neo-prop:Since 2022 .
+ }
+ TRIG;
+ }
+
+ /**
+ * @return list
+ */
+ private function distinctGraphs( QuadList $quads ): array {
+ return array_values( array_unique( array_map(
+ static fn ( Quad $quad ): string => $quad->graph->value,
+ $quads->asArray()
+ ) ) );
+ }
+
/**
* A user-authored Property or Schema name must never break out of its IRI: illegal characters
* are escaped so the document still parses to exactly the intended quads. The confirmed repro
diff --git a/tests/phpunit/Application/Rdf/RdfSubjectExporterTest.php b/tests/phpunit/Application/Rdf/RdfSubjectExporterTest.php
new file mode 100644
index 000000000..633110c35
--- /dev/null
+++ b/tests/phpunit/Application/Rdf/RdfSubjectExporterTest.php
@@ -0,0 +1,138 @@
+exporter(
+ lookup: new InMemoryPageIdentifiersLookup(),
+ loadedPage: $this->pageWithTheSubject(),
+ authorized: true,
+ );
+
+ $this->assertNull( $exporter->exportBySubjectId( new SubjectId( self::SUBJECT_ID ), RdfFormat::TriG ) );
+ }
+
+ public function testReturnsNullWhenTheHostingPageIsNotReadable(): void {
+ $exporter = $this->exporter(
+ lookup: $this->lookupResolvingTheSubject(),
+ loadedPage: $this->pageWithTheSubject(),
+ authorized: false,
+ );
+
+ $this->assertNull( $exporter->exportBySubjectId( new SubjectId( self::SUBJECT_ID ), RdfFormat::TriG ) );
+ }
+
+ public function testReturnsNullWhenTheHostingPageCannotBeLoaded(): void {
+ $exporter = $this->exporter(
+ lookup: $this->lookupResolvingTheSubject(),
+ loadedPage: null,
+ authorized: true,
+ );
+
+ $this->assertNull( $exporter->exportBySubjectId( new SubjectId( self::SUBJECT_ID ), RdfFormat::TriG ) );
+ }
+
+ public function testReturnsNullWhenTheGraphPointsToAPageThatNoLongerHasTheSubject(): void {
+ // Stale graph: it resolves the Subject to a page whose current revision no longer carries it.
+ $exporter = $this->exporter(
+ lookup: $this->lookupResolvingTheSubject(),
+ loadedPage: TestPage::build( id: 42, mainSubject: TestSubject::build( id: self::OTHER_ID ) ),
+ authorized: true,
+ );
+
+ $this->assertNull( $exporter->exportBySubjectId( new SubjectId( self::SUBJECT_ID ), RdfFormat::TriG ) );
+ }
+
+ public function testSerializesTheProjectedSubjectWhenItIsPresentAndReadable(): void {
+ $quads = new QuadList(
+ new Quad(
+ new Iri( 'https://wiki.example/entity/' . self::SUBJECT_ID ),
+ new Iri( 'http://www.w3.org/2000/01/rdf-schema#label' ),
+ RdfLiteralFactory::typed( 'ACME Corp', 'string' ),
+ new Iri( 'https://wiki.example/graph/native/page/42' ),
+ )
+ );
+
+ $document = $this->exporter(
+ lookup: $this->lookupResolvingTheSubject(),
+ loadedPage: $this->pageWithTheSubject(),
+ authorized: true,
+ projector: new FixedPageProjector( $quads ),
+ )->exportBySubjectId( new SubjectId( self::SUBJECT_ID ), RdfFormat::TriG );
+
+ $this->assertSame(
+ ( new HardfRdfSerializer( [] ) )->serialize( $quads, RdfFormat::TriG ),
+ $document,
+ 'The document is the projected Subject serialized in the requested format.'
+ );
+ }
+
+ private function exporter(
+ InMemoryPageIdentifiersLookup $lookup,
+ ?Page $loadedPage,
+ bool $authorized,
+ ?PageProjector $projector = null
+ ): RdfSubjectExporter {
+ return new RdfSubjectExporter(
+ $lookup,
+ $this->fixedLoader( $loadedPage ),
+ $projector ?? new FixedPageProjector( new QuadList() ),
+ new HardfRdfSerializer( [] ),
+ new StubPageReadAuthorizer( $authorized ),
+ );
+ }
+
+ private function lookupResolvingTheSubject(): InMemoryPageIdentifiersLookup {
+ return new InMemoryPageIdentifiersLookup( [
+ [ new SubjectId( self::SUBJECT_ID ), new PageIdentifiers( new PageId( 42 ), 'ACME Corp', 0 ) ],
+ ] );
+ }
+
+ private function pageWithTheSubject(): Page {
+ return TestPage::build( id: 42, mainSubject: TestSubject::build( id: self::SUBJECT_ID ) );
+ }
+
+ private function fixedLoader( ?Page $page ): RdfPageLoader {
+ return new class( $page ) extends RdfPageLoader {
+
+ public function __construct( private readonly ?Page $page ) {
+ }
+
+ public function loadByPageId( PageId $pageId ): ?Page {
+ return $this->page;
+ }
+
+ };
+ }
+
+}
diff --git a/tests/phpunit/EntryPoints/Actions/SubjectsActionTest.php b/tests/phpunit/EntryPoints/Actions/SubjectsActionTest.php
index 4347d4621..b58a846ce 100644
--- a/tests/phpunit/EntryPoints/Actions/SubjectsActionTest.php
+++ b/tests/phpunit/EntryPoints/Actions/SubjectsActionTest.php
@@ -4,14 +4,22 @@
namespace ProfessionalWiki\NeoWiki\Tests\EntryPoints\Actions;
+use Article;
+use MediaWiki\Context\RequestContext;
+use MediaWiki\Output\OutputPage;
+use MediaWiki\Permissions\Authority;
use MediaWiki\Title\Title;
-use MediaWikiIntegrationTestCase;
use ProfessionalWiki\NeoWiki\EntryPoints\Actions\SubjectsAction;
+use ProfessionalWiki\NeoWiki\Tests\NeoWikiIntegrationTestCase;
+use ProfessionalWiki\NeoWiki\Tests\NeoWikiMockAuthorityTrait;
/**
* @covers \ProfessionalWiki\NeoWiki\EntryPoints\Actions\SubjectsAction
+ * @group Database
*/
-class SubjectsActionTest extends MediaWikiIntegrationTestCase {
+class SubjectsActionTest extends NeoWikiIntegrationTestCase {
+
+ use NeoWikiMockAuthorityTrait;
public function testNullTitleIsNotEligible(): void {
$this->assertFalse( SubjectsAction::isEligibleTitle( null ) );
@@ -43,4 +51,42 @@ public function testTitleInContentNamespaceIsEligible(): void {
$this->assertTrue( SubjectsAction::isEligibleTitle( $title ) );
}
+ public function testExposesReadableRdfProjectionsAsConfigVar(): void {
+ $this->createMapping( 'EDM', '{ "version": 1, "schemas": {} }' );
+
+ $out = $this->runOnView( 'SubjectsActionTest projections', $this->getTestSysop()->getAuthority() );
+
+ $this->assertSame(
+ [ 'native', 'EDM' ],
+ $out->getJsConfigVars()['wgNeoWikiRdfProjections']
+ );
+ }
+
+ public function testOmitsRdfProjectionsTheViewingUserCannotRead(): void {
+ $this->createMapping( 'EDM', '{ "version": 1, "schemas": {} }' );
+
+ $out = $this->runOnView(
+ 'SubjectsActionTest restricted',
+ $this->authorityWithGlobalReadButNoPageRead()
+ );
+
+ $this->assertSame(
+ [ 'native' ],
+ $out->getJsConfigVars()['wgNeoWikiRdfProjections'],
+ 'A read-restricted Mapping page name must not reach a reader who cannot see it.'
+ );
+ }
+
+ private function runOnView( string $pageName, Authority $authority ): OutputPage {
+ $title = $this->getExistingTestPage( $pageName )->getTitle();
+
+ $context = new RequestContext();
+ $context->setTitle( $title );
+ $context->setAuthority( $authority );
+
+ ( new SubjectsAction( Article::newFromTitle( $title, $context ), $context ) )->onView();
+
+ return $context->getOutput();
+ }
+
}
diff --git a/tests/phpunit/EntryPoints/REST/ExportSubjectRdfApiTest.php b/tests/phpunit/EntryPoints/REST/ExportSubjectRdfApiTest.php
new file mode 100644
index 000000000..f6014fa20
--- /dev/null
+++ b/tests/phpunit/EntryPoints/REST/ExportSubjectRdfApiTest.php
@@ -0,0 +1,310 @@
+setUpNeo4j();
+
+ $this->createSchema(
+ self::SCHEMA,
+ <<pageId = $this->createPageWithSubjects(
+ 'ExportSubjectRdfApiTest_Cities',
+ mainSubject: TestSubject::build(
+ id: self::BERLIN_ID,
+ label: new SubjectLabel( 'Berlin' ),
+ schemaName: new SchemaName( self::SCHEMA ),
+ statements: new StatementList( [
+ TestStatement::build( 'population', '3700000' ),
+ ] )
+ ),
+ childSubjects: new SubjectMap(
+ TestSubject::build(
+ id: self::PARIS_ID,
+ label: new SubjectLabel( 'Paris' ),
+ schemaName: new SchemaName( self::SCHEMA ),
+ statements: new StatementList( [
+ TestStatement::build( 'population', '2100000' ),
+ ] )
+ )
+ ),
+ )->getPage()->getId();
+ }
+
+ /**
+ * @param array $query
+ * @param array $headers
+ */
+ private function export( array $query = [], array $headers = [], ?string $subjectId = null, ?Authority $authority = null ): Response {
+ return $this->executeHandler(
+ new ExportSubjectRdfApi(),
+ new RequestData( [
+ 'method' => 'GET',
+ 'pathParams' => [ 'subjectId' => $subjectId ?? self::BERLIN_ID ],
+ 'queryParams' => $query,
+ 'headers' => $headers,
+ ] ),
+ authority: $authority
+ );
+ }
+
+ public function testDefaultsToTriGWithTheHostingPagesNamedGraph(): void {
+ $response = $this->export();
+ $body = $response->getBody()->getContents();
+
+ $this->assertSame( 200, $response->getStatusCode() );
+ $this->assertSame( 'application/trig; charset=utf-8', $response->getHeaderLine( 'Content-Type' ) );
+ $this->assertStringContainsString( 'Berlin', $body );
+ $this->assertStringEndsWith(
+ '/graph/native/page/' . $this->pageId,
+ $this->soleGraphIn( $body ),
+ 'Every TriG quad belongs to the hosting page\'s named graph.'
+ );
+ }
+
+ public function testFormatParameterSelectsTurtleWithoutANamedGraph(): void {
+ $response = $this->export( query: [ 'format' => 'turtle' ] );
+ $body = $response->getBody()->getContents();
+
+ $this->assertSame( 200, $response->getStatusCode() );
+ $this->assertSame( 'text/turtle; charset=utf-8', $response->getHeaderLine( 'Content-Type' ) );
+ $this->assertStringContainsString( 'Berlin', $body );
+ $this->assertSame( [ '' ], $this->graphsIn( $body ), 'Turtle drops the named graph.' );
+ }
+
+ public function testFormatParameterOverridesTheAcceptHeader(): void {
+ $response = $this->export( query: [ 'format' => 'trig' ], headers: [ 'Accept' => 'text/turtle' ] );
+
+ $this->assertSame( 200, $response->getStatusCode() );
+ $this->assertSame( 'application/trig; charset=utf-8', $response->getHeaderLine( 'Content-Type' ) );
+ }
+
+ public function testAcceptHeaderSelectsTurtle(): void {
+ $response = $this->export( headers: [ 'Accept' => 'text/turtle' ] );
+
+ $this->assertSame( 200, $response->getStatusCode() );
+ $this->assertSame( 'text/turtle; charset=utf-8', $response->getHeaderLine( 'Content-Type' ) );
+ $this->assertSame( [ '' ], $this->graphsIn( $response->getBody()->getContents() ) );
+ }
+
+ public function testAcceptHeaderSelectsTriG(): void {
+ $response = $this->export( headers: [ 'Accept' => 'application/trig' ] );
+
+ $this->assertSame( 200, $response->getStatusCode() );
+ $this->assertSame( 'application/trig; charset=utf-8', $response->getHeaderLine( 'Content-Type' ) );
+ }
+
+ public function testReturns404ForAnUnknownSubject(): void {
+ $response = $this->export( subjectId: self::ABSENT_ID );
+
+ $this->assertSame( 404, $response->getStatusCode() );
+ $this->assertStringContainsString(
+ 'No NeoWiki data found for subject: ' . self::ABSENT_ID,
+ $response->getBody()->getContents()
+ );
+ }
+
+ public function testSubjectOnAnUnreadablePageIsByteIdenticalToAnAbsentSubject(): void {
+ // An existing Subject whose hosting page the caller cannot read must answer exactly like an
+ // absent Subject, so the endpoint cannot confirm a harvested Subject id exists (#1046). Only the
+ // Subject id echoed in the message differs between the two.
+ $denied = $this->export( authority: $this->authorityWithGlobalReadButNoPageRead() );
+ $absent = $this->export( subjectId: self::ABSENT_ID );
+
+ $this->assertSame( 404, $denied->getStatusCode() );
+ $this->assertSame( $absent->getStatusCode(), $denied->getStatusCode() );
+ $this->assertSame(
+ $absent->getHeaderLine( 'Content-Type' ),
+ $denied->getHeaderLine( 'Content-Type' )
+ );
+ $this->assertSame(
+ str_replace( self::ABSENT_ID, self::BERLIN_ID, $absent->getBody()->getContents() ),
+ $denied->getBody()->getContents()
+ );
+ }
+
+ public function testUnknownProjectionReturns400EvenForAnAbsentSubject(): void {
+ // The projection check runs before the Subject is resolved, so a caller cannot use a valid vs
+ // invalid projection to probe whether a Subject exists.
+ $response = $this->export(
+ query: [ 'projection' => 'no-such-projection' ],
+ subjectId: self::ABSENT_ID
+ );
+
+ $this->assertSame( 400, $response->getStatusCode() );
+ }
+
+ public function testReturns400ForAMalformedSubjectId(): void {
+ $response = $this->export( subjectId: 'not-a-valid-id' );
+
+ $this->assertSame( 400, $response->getStatusCode() );
+ }
+
+ public function testReadRestrictedMappingNamesAreAbsentFromTheKnownProjectionsList(): void {
+ // The unknown-projection 400 list must not leak the titles of Mapping pages the caller cannot
+ // read (#1046). A caller who can read the page sees "EDM"; one who cannot must not — though
+ // "native" (not a page) stays listed for everyone.
+ $this->createEdmMapping();
+
+ $readable = $this->export( query: [ 'projection' => 'bogus' ] );
+ $restricted = $this->export(
+ query: [ 'projection' => 'bogus' ],
+ authority: $this->authorityWithGlobalReadButNoPageRead()
+ );
+
+ $this->assertStringContainsString( 'EDM', $readable->getBody()->getContents() );
+
+ $restrictedBody = $restricted->getBody()->getContents();
+ $this->assertStringNotContainsString( 'EDM', $restrictedBody, 'A read-restricted Mapping page name must not leak into the 400 list.' );
+ $this->assertStringContainsString( 'native', $restrictedBody, 'The always-available native projection stays listed.' );
+ }
+
+ public function testOmittedProjectionEqualsExplicitNative(): void {
+ $default = $this->export();
+ $explicit = $this->export( query: [ 'projection' => 'native' ] );
+
+ $this->assertSame( 200, $explicit->getStatusCode() );
+ $this->assertSame(
+ ParsedRdf::canonicalQuads( $default->getBody()->getContents() ),
+ ParsedRdf::canonicalQuads( $explicit->getBody()->getContents() )
+ );
+ }
+
+ public function testValidTargetProjectsTheMappedVocabularyWithNativeSubjectIris(): void {
+ $this->createEdmMapping();
+
+ $response = $this->export( query: [ 'projection' => 'EDM', 'format' => 'turtle' ] );
+ $body = $response->getBody()->getContents();
+
+ $this->assertSame( 200, $response->getStatusCode() );
+ $this->assertStringContainsString( 'europeana.eu/schemas/edm', $body, 'The mapped ontology vocabulary is used.' );
+ $this->assertStringContainsString( self::BERLIN_ID, $body, 'The Subject IRI stays native.' );
+ $this->assertStringNotContainsString( self::SCHEMA, $body, 'No native schema class is emitted.' );
+ }
+
+ public function testReadableSubjectWithoutAMappingForTheTargetReturnsAnEmptyGraph(): void {
+ // "EDM" is a known projection because Berlin's Schema has an entry on the Mapping page, but this
+ // Subject's Schema does not, so its ontology projection is empty. A readable Subject is never
+ // hidden behind a 404, so the response is a 200 empty graph rather than a not-found.
+ $this->createEdmMapping();
+
+ $this->createSchema( 'ExportSubjectRdfApiTestUnmappedSchema' );
+ $this->createPageWithSubjects(
+ 'ExportSubjectRdfApiTest_Unmapped',
+ mainSubject: TestSubject::build(
+ id: self::UNMAPPED_ID,
+ label: new SubjectLabel( 'Freetown' ),
+ schemaName: new SchemaName( 'ExportSubjectRdfApiTestUnmappedSchema' )
+ )
+ );
+
+ $response = $this->export( query: [ 'projection' => 'EDM', 'format' => 'turtle' ], subjectId: self::UNMAPPED_ID );
+
+ $this->assertSame( 200, $response->getStatusCode() );
+ $this->assertSame(
+ [],
+ ParsedRdf::canonicalQuads( $response->getBody()->getContents() ),
+ 'A readable Subject with no Mapping for the target projects to an empty graph, not a 404.'
+ );
+ }
+
+ public function testReturnsOnlyTheRequestedSubjectsTriples(): void {
+ $body = $this->export()->getBody()->getContents();
+
+ $this->assertStringContainsString( 'Berlin', $body, 'The requested Subject is present.' );
+ $this->assertStringNotContainsString( 'Paris', $body, 'A sibling Subject on the same page is not included.' );
+ $this->assertStringNotContainsString( self::PARIS_ID, $body, 'A sibling Subject IRI is not included.' );
+ }
+
+ private function createEdmMapping(): void {
+ $this->createMapping( 'EDM', <<schemaName()}": {
+ "subject": { "class": "edm:Place" },
+ "properties": {
+ "population": { "predicate": "dc:description" }
+ }
+ }
+ }
+ }
+ JSON );
+ }
+
+ private function schemaName(): string {
+ return self::SCHEMA;
+ }
+
+ /**
+ * The single named graph every quad in the document belongs to.
+ */
+ private function soleGraphIn( string $rdf ): string {
+ $graphs = $this->graphsIn( $rdf );
+
+ $this->assertCount( 1, $graphs, 'A per-Subject projection places every quad in exactly one named graph.' );
+
+ return $graphs[0];
+ }
+
+ /**
+ * The graph value (the fourth field of each canonical quad) of every quad in the parsed document.
+ * Distinguishes TriG (a non-empty page graph on every quad) from Turtle (the empty default graph).
+ *
+ * @return list
+ */
+ private function graphsIn( string $rdf ): array {
+ return array_values( array_unique( array_map(
+ static fn ( string $line ): string => explode( "\t", $line )[3],
+ ParsedRdf::canonicalQuads( $rdf )
+ ) ) );
+ }
+
+}
diff --git a/tests/phpunit/EntryPoints/RdfAutodiscoveryLinksTest.php b/tests/phpunit/EntryPoints/RdfAutodiscoveryLinksTest.php
new file mode 100644
index 000000000..4b03ec5eb
--- /dev/null
+++ b/tests/phpunit/EntryPoints/RdfAutodiscoveryLinksTest.php
@@ -0,0 +1,83 @@
+setUpNeo4j();
+ $this->createSchema( TestSubject::DEFAULT_SCHEMA_ID );
+ $this->markPageTableAsUsed();
+ }
+
+ public function testAdvertisesTurtleAndTrigExportsForPageWithSubjects(): void {
+ $revision = $this->createPageWithSubjects(
+ 'Autodiscovery with subjects',
+ TestSubject::build( id: self::SUBJECT_ID )
+ );
+
+ $out = $this->renderContentPage( 'Autodiscovery with subjects', $revision->getId() );
+ $pageId = $revision->getPageId();
+
+ $turtle = $this->alternateLinkHref( $out, 'text/turtle' );
+ $trig = $this->alternateLinkHref( $out, 'application/trig' );
+
+ $this->assertNotNull( $turtle, 'A text/turtle alternate link is expected on a page with Subjects.' );
+ $this->assertNotNull( $trig, 'An application/trig alternate link is expected on a page with Subjects.' );
+ $this->assertStringContainsString( "/neowiki/v0/page/{$pageId}/rdf?projection=native&format=turtle", $turtle );
+ $this->assertStringContainsString( "/neowiki/v0/page/{$pageId}/rdf?projection=native&format=trig", $trig );
+ // Absolute (canonical) URLs, not relative paths, so Linked Data tooling can dereference them.
+ $this->assertStringStartsWith( 'http', $turtle );
+ $this->assertStringStartsWith( 'http', $trig );
+ }
+
+ public function testDoesNotAdvertiseExportsForPageWithoutSubjects(): void {
+ $this->editPage( 'Autodiscovery without subjects', 'Plain page, no NeoWiki data.' );
+ $revisionId = Title::newFromText( 'Autodiscovery without subjects' )->getLatestRevID();
+
+ $out = $this->renderContentPage( 'Autodiscovery without subjects', $revisionId );
+
+ $this->assertNull( $this->alternateLinkHref( $out, 'text/turtle' ) );
+ $this->assertNull( $this->alternateLinkHref( $out, 'application/trig' ) );
+ }
+
+ private function renderContentPage( string $pageName, int $revisionId ): OutputPage {
+ $context = new RequestContext();
+ $context->setTitle( Title::newFromText( $pageName ) );
+
+ $out = $context->getOutput();
+ $out->setArticleFlag( true );
+ $out->setRevisionId( $revisionId );
+
+ NeoWikiHooks::onBeforePageDisplay( $out, $context->getSkin() );
+
+ return $out;
+ }
+
+ private function alternateLinkHref( OutputPage $out, string $type ): ?string {
+ foreach ( $out->getLinkTags() as $tag ) {
+ if ( ( $tag['rel'] ?? null ) === 'alternate' && ( $tag['type'] ?? null ) === $type ) {
+ return $tag['href'] ?? null;
+ }
+ }
+
+ return null;
+ }
+
+}
diff --git a/tests/phpunit/TestDoubles/FixedPageProjector.php b/tests/phpunit/TestDoubles/FixedPageProjector.php
index 090e30dc0..245d24da0 100644
--- a/tests/phpunit/TestDoubles/FixedPageProjector.php
+++ b/tests/phpunit/TestDoubles/FixedPageProjector.php
@@ -7,6 +7,7 @@
use ProfessionalWiki\NeoWiki\Application\Rdf\PageProjector;
use ProfessionalWiki\NeoWiki\Domain\Page\Page;
use ProfessionalWiki\NeoWiki\Domain\Rdf\QuadList;
+use ProfessionalWiki\NeoWiki\Domain\Subject\SubjectId;
/**
* A {@see PageProjector} that returns a preset {@see QuadList} regardless of the page, so tests can
@@ -23,4 +24,8 @@ public function projectPage( Page $page ): QuadList {
return $this->quads;
}
+ public function projectSubject( Page $page, SubjectId $subjectId ): QuadList {
+ return $this->quads;
+ }
+
}