@glossarist/concept-browser 0.7.50 → 0.7.52

package/src/__tests__/concept-rdf/agents-emitter.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect } from 'vitest';
+import { Parser, Store } from 'n3';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import {
+  agentsFromContributors,
+  emitAgentsGraph,
+} from '../../components/concept-rdf/agents-emitter';
+
+const FOAF = 'http://xmlns.com/foaf/0.1/';
+const PROV = 'http://www.w3.org/ns/prov#';
+const DCTERMS = 'http://purl.org/dc/terms/';
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+
+function parse(turtle: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  return store;
+}
+
+describe('agentsFromContributors', () => {
+  it('turns each contributor into an AgentInput with a slugified IRI', () => {
+    const agents = agentsFromContributors([
+      { name: 'Ada Lovelace', role: 'Editor', organization: 'Royal Society', email: 'ada@example.org' },
+      { name: 'Grace Hopper', organization: 'USN' },
+    ]);
+    expect(agents.length).toBe(2);
+    expect(agents[0].agentIri).toBe('https://glossarist.org/agent/ada-lovelace');
+    expect(agents[1].agentIri).toBe('https://glossarist.org/agent/grace-hopper');
+    expect(agents[0].role).toBe('Editor');
+  });
+
+  it('deduplicates organizations by slug', () => {
+    const result = emitAgentsGraph(agentsFromContributors([
+      { name: 'Alice', organization: 'ISO' },
+      { name: 'Bob',   organization: 'ISO' },
+      { name: 'Carol', organization: 'IEC' },
+    ]));
+    expect(result.organizationIris.length).toBe(2);
+  });
+});
+
+describe('emitAgentsGraph — J4 agent records', () => {
+  it('types each person as foaf:Person, prov:Person, prov:Agent', () => {
+    const graph = emitAgentsGraph(agentsFromContributors([
+      { name: 'Ada Lovelace', email: 'ada@example.org' },
+    ]));
+    const store = parse(writeTurtle(graph.graph));
+    const types = store.getObjects('https://glossarist.org/agent/ada-lovelace', RDF_TYPE, null).map(q => q.value);
+    expect(types).toContain(`${FOAF}Person`);
+    expect(types).toContain(`${PROV}Person`);
+    expect(types).toContain(`${PROV}Agent`);
+  });
+
+  it('records name, email (as mailto IRI), role, and url', () => {
+    const graph = emitAgentsGraph(agentsFromContributors([
+      { name: 'Ada Lovelace', role: 'Editor', email: 'ada@example.org', url: 'https://example.org/ada' },
+    ]));
+    const store = parse(writeTurtle(graph.graph));
+    const names = store.getObjects('https://glossarist.org/agent/ada-lovelace', `${FOAF}name`, null).map(q => q.value);
+    expect(names).toContain('Ada Lovelace');
+
+    const mboxes = store.getObjects('https://glossarist.org/agent/ada-lovelace', `${FOAF}mbox`, null).map(q => q.value);
+    expect(mboxes).toContain('mailto:ada@example.org');
+
+    const roles = store.getObjects('https://glossarist.org/agent/ada-lovelace', `${DCTERMS}description`, null).map(q => q.value);
+    expect(roles).toContain('Editor');
+
+    const seeAlso = store.getObjects('https://glossarist.org/agent/ada-lovelace', 'http://www.w3.org/2000/01/rdf-schema#seeAlso', null).map(q => q.value);
+    expect(seeAlso).toContain('https://example.org/ada');
+  });
+
+  it('creates a single prov:Organization per unique organization', () => {
+    const result = emitAgentsGraph(agentsFromContributors([
+      { name: 'Alice', organization: 'ISO' },
+      { name: 'Bob',   organization: 'ISO' },
+    ]));
+    expect(result.organizationIris).toEqual(['https://glossarist.org/org/iso']);
+
+    const store = parse(writeTurtle(result.graph));
+    const types = store.getObjects('https://glossarist.org/org/iso', RDF_TYPE, null).map(q => q.value);
+    expect(types).toContain(`${FOAF}Organization`);
+    expect(types).toContain(`${PROV}Organization`);
+    expect(types).toContain(`${PROV}Agent`);
+
+    const names = store.getObjects('https://glossarist.org/org/iso', `${FOAF}name`, null).map(q => q.value);
+    expect(names).toContain('ISO');
+  });
+
+  it('links every person to their organization via prov:actedOnBehalfOf', () => {
+    const result = emitAgentsGraph(agentsFromContributors([
+      { name: 'Alice', organization: 'ISO' },
+      { name: 'Bob',   organization: 'IEC' },
+    ]));
+    const store = parse(writeTurtle(result.graph));
+    const aliceOrg = store.getObjects('https://glossarist.org/agent/alice', `${PROV}actedOnBehalfOf`, null).map(q => q.value);
+    expect(aliceOrg).toContain('https://glossarist.org/org/iso');
+    const bobOrg = store.getObjects('https://glossarist.org/agent/bob', `${PROV}actedOnBehalfOf`, null).map(q => q.value);
+    expect(bobOrg).toContain('https://glossarist.org/org/iec');
+  });
+
+  it('omits mbox, seeAlso, and actedOnBehalfOf when not provided', () => {
+    const graph = emitAgentsGraph(agentsFromContributors([{ name: 'Solo' }]));
+    const store = parse(writeTurtle(graph.graph));
+    const mbox = store.getObjects('https://glossarist.org/agent/solo', `${FOAF}mbox`, null);
+    expect(mbox).toHaveLength(0);
+    const acted = store.getObjects('https://glossarist.org/agent/solo', `${PROV}actedOnBehalfOf`, null);
+    expect(acted).toHaveLength(0);
+  });
+});

package/src/__tests__/concept-rdf/bibliography-emitter.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect } from 'vitest';
+import { Parser, Store } from 'n3';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import {
+  emitBibliographyGraph,
+  bibliographyEntryIri,
+  normalizeBibliographyData,
+} from '../../components/concept-rdf/bibliography-emitter';
+
+const FOAF = 'http://xmlns.com/foaf/0.1/';
+const DCTERMS = 'http://purl.org/dc/terms/';
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+
+function parse(turtle: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  return store;
+}
+
+describe('emitBibliographyGraph — K5 bibliography graph', () => {
+  it('types each entry as dcterms:BibliographicResource', () => {
+    const graph = emitBibliographyGraph({
+      registerId: 'iso-geodetic',
+      entries: [{ id: 'iso-704', reference: 'ISO 704' }],
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = bibliographyEntryIri('iso-geodetic', 'iso-704');
+    const types = store.getObjects(iri, RDF_TYPE, null).map(q => q.value);
+    expect(types).toContain(`${DCTERMS}BibliographicResource`);
+  });
+
+  it('emits identifier, bibliographicCitation, and title as literals', () => {
+    const graph = emitBibliographyGraph({
+      registerId: 'iso-geodetic',
+      entries: [
+        { id: 'iso-704', reference: 'ISO 704', title: 'Terminology work — Principles and methods' },
+      ],
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = bibliographyEntryIri('iso-geodetic', 'iso-704');
+    const ids = store.getObjects(iri, `${DCTERMS}identifier`, null).map(q => q.value);
+    expect(ids).toContain('iso-704');
+    const cites = store.getObjects(iri, `${DCTERMS}bibliographicCitation`, null).map(q => q.value);
+    expect(cites).toContain('ISO 704');
+    const titles = store.getObjects(iri, `${DCTERMS}title`, null).map(q => q.value);
+    expect(titles).toContain('Terminology work — Principles and methods');
+  });
+
+  it('emits foaf:page when link is provided', () => {
+    const graph = emitBibliographyGraph({
+      registerId: 'iso-geodetic',
+      entries: [{ id: 'ref', reference: 'X', link: 'https://example.org/x' }],
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = bibliographyEntryIri('iso-geodetic', 'ref');
+    const pages = store.getObjects(iri, `${FOAF}page`, null).map(q => q.value);
+    expect(pages).toContain('https://example.org/x');
+  });
+
+  it('omits foaf:page when link is absent', () => {
+    const graph = emitBibliographyGraph({
+      registerId: 'iso-geodetic',
+      entries: [{ id: 'no-link', reference: 'Y' }],
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = bibliographyEntryIri('iso-geodetic', 'no-link');
+    const pages = store.getObjects(iri, `${FOAF}page`, null);
+    expect(pages).toHaveLength(0);
+  });
+
+  it('emits one resource per entry', () => {
+    const graph = emitBibliographyGraph({
+      registerId: 'iso-geodetic',
+      entries: [
+        { id: 'a', reference: 'A' },
+        { id: 'b', reference: 'B' },
+        { id: 'c', reference: 'C' },
+      ],
+    });
+    const iriA = bibliographyEntryIri('iso-geodetic', 'a');
+    const iriB = bibliographyEntryIri('iso-geodetic', 'b');
+    const iriC = bibliographyEntryIri('iso-geodetic', 'c');
+    const store = parse(writeTurtle(graph));
+    expect(store.getObjects(iriA, `${DCTERMS}bibliographicCitation`, null).map(q => q.value)).toContain('A');
+    expect(store.getObjects(iriB, `${DCTERMS}bibliographicCitation`, null).map(q => q.value)).toContain('B');
+    expect(store.getObjects(iriC, `${DCTERMS}bibliographicCitation`, null).map(q => q.value)).toContain('C');
+  });
+
+  it('links each entry to the dataset via dcterms:isPartOf', () => {
+    const graph = emitBibliographyGraph({
+      registerId: 'iso-geodetic',
+      entries: [{ id: 'a', reference: 'A' }],
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = bibliographyEntryIri('iso-geodetic', 'a');
+    const parts = store.getObjects(iri, `${DCTERMS}isPartOf`, null).map(q => q.value);
+    expect(parts).toContain('https://glossarist.org/iso-geodetic/');
+  });
+});
+
+describe('B3/C — V3 bibliography shape (wrapper key)', () => {
+  it('normalizeBibliographyData unwraps { bibliography: [...] } V3 shape', () => {
+    const v3 = {
+      bibliography: [
+        { id: 'iso704', reference: 'ISO 704', title: 'Terminology work', type: 'normative' },
+        { id: 'iso10241', reference: 'ISO 10241-1' },
+      ],
+    };
+    const entries = normalizeBibliographyData(v3);
+    expect(entries.length).toBe(2);
+    expect(entries[0].id).toBe('iso704');
+    expect(entries[0].type).toBe('normative');
+    expect(entries[1].id).toBe('iso10241');
+  });
+
+  it('normalizeBibliographyData accepts the legacy flat-map shape', () => {
+    const legacy = {
+      iso704: { reference: 'ISO 704', title: 'Terminology work' },
+      iso10241: { reference: 'ISO 10241-1' },
+    };
+    const entries = normalizeBibliographyData(legacy);
+    expect(entries.length).toBe(2);
+    expect(entries.find(e => e.id === 'iso704')?.title).toBe('Terminology work');
+  });
+
+  it('emitBibliographyGraph handles both V3 and legacy shapes identically', () => {
+    const v3 = { bibliography: [{ id: 'iso704', reference: 'ISO 704', title: 'T' }] };
+    const legacy = { iso704: { reference: 'ISO 704', title: 'T' } };
+
+    const graphV3 = emitBibliographyGraph({
+      registerId: 'r',
+      entries: normalizeBibliographyData(v3),
+    });
+    const graphLegacy = emitBibliographyGraph({
+      registerId: 'r',
+      entries: normalizeBibliographyData(legacy),
+    });
+
+    const storeV3 = parse(writeTurtle(graphV3));
+    const storeLegacy = parse(writeTurtle(graphLegacy));
+
+    const iri = bibliographyEntryIri('r', 'iso704');
+    const v3Titles = storeV3.getObjects(iri, `${DCTERMS}title`, null).map(q => q.value);
+    const legacyTitles = storeLegacy.getObjects(iri, `${DCTERMS}title`, null).map(q => q.value);
+    expect(v3Titles).toEqual(legacyTitles);
+  });
+
+  it('emits dcterms:type when entry.type is provided', () => {
+    const graph = emitBibliographyGraph({
+      registerId: 'r',
+      entries: [{ id: 'a', reference: 'X', type: 'normative' }],
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = bibliographyEntryIri('r', 'a');
+    const types = store.getObjects(iri, `${DCTERMS}type`, null).map(q => q.value);
+    expect(types.some(t => t.includes('bibtype/normative'))).toBe(true);
+  });
+});

package/src/__tests__/concept-rdf/build-activity-emitter.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect } from 'vitest';
+import { Parser, Store } from 'n3';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import { emitBuildActivityGraph, activityIri } from '../../components/concept-rdf/build-activity-emitter';
+import type { BuildActivityInput } from '../../components/concept-rdf/build-activity-emitter';
+
+function makeInput(overrides: Partial<BuildActivityInput> = {}): BuildActivityInput {
+  return {
+    runId: '2026-06-28T12-00-00Z',
+    startedAt: '2026-06-28T12:00:00Z',
+    endedAt: '2026-06-28T12:05:00Z',
+    gitSha: 'abc1234',
+    gitBranch: 'main',
+    toolId: 'concept-browser',
+    toolVersion: '0.7.51',
+    datasetRegisters: ['iso-geodetic', 'iso-10303-2-terms'],
+    conceptCount: 1234,
+    associatedAgentIri: 'https://glossarist.org/agent/ci-bot',
+    ...overrides,
+  };
+}
+
+function parse(turtle: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  return store;
+}
+
+const expand = (v: string): string => {
+  if (v.startsWith('prov:'))    return `http://www.w3.org/ns/prov#${v.slice(5)}`;
+  if (v.startsWith('dcterms:')) return `http://purl.org/dc/terms/${v.slice(8)}`;
+  if (v.startsWith('rdf:'))     return `http://www.w3.org/1999/02/22-rdf-syntax-ns#${v.slice(4)}`;
+  if (v.startsWith('xsd:'))     return `http://www.w3.org/2001/XMLSchema#${v.slice(4)}`;
+  if (v.startsWith('foaf:'))    return `http://xmlns.com/foaf/0.1/${v.slice(5)}`;
+  return v;
+};
+
+describe('emitBuildActivityGraph — J7 build activity records', () => {
+  it('types the activity as prov:Activity', () => {
+    const input = makeInput();
+    const graph = emitBuildActivityGraph(input);
+    const store = parse(writeTurtle(graph));
+    const iri = activityIri(input);
+    const types = store.getObjects(iri, expand('rdf:type'), null).map(q => q.value);
+    expect(types).toContain(expand('prov:Activity'));
+  });
+
+  it('records the start and end times', () => {
+    const input = makeInput();
+    const graph = emitBuildActivityGraph(input);
+    const store = parse(writeTurtle(graph));
+    const iri = activityIri(input);
+    const generated = store.getObjects(iri, expand('prov:generatedAtTime'), null).map(q => q.value);
+    expect(generated).toContain('2026-06-28T12:05:00Z');
+  });
+
+  it('types the tool as prov:SoftwareAgent with version', () => {
+    const input = makeInput();
+    const graph = emitBuildActivityGraph(input);
+    const store = parse(writeTurtle(graph));
+    const toolIri = `https://glossarist.org/tool/${input.toolId}/${input.toolVersion}`;
+    const types = store.getObjects(toolIri, expand('rdf:type'), null).map(q => q.value);
+    expect(types).toContain(expand('prov:SoftwareAgent'));
+    const version = store.getObjects(toolIri, expand('prov:version'), null).map(q => q.value);
+    expect(version).toContain(input.toolVersion);
+  });
+
+  it('records the git commit and the tool as prov:used entities', () => {
+    const input = makeInput();
+    const graph = emitBuildActivityGraph(input);
+    const store = parse(writeTurtle(graph));
+    const iri = activityIri(input);
+    const used = store.getObjects(iri, expand('prov:used'), null).map(q => q.value);
+    expect(used).toContain(`https://glossarist.org/commit/${input.gitSha}`);
+    expect(used).toContain(`https://glossarist.org/tool/${input.toolId}/${input.toolVersion}`);
+  });
+
+  it('references every dataset register via prov:used', () => {
+    const input = makeInput();
+    const graph = emitBuildActivityGraph(input);
+    const store = parse(writeTurtle(graph));
+    const iri = activityIri(input);
+    const used = store.getObjects(iri, expand('prov:used'), null).map(q => q.value);
+    for (const register of input.datasetRegisters) {
+      expect(used).toContain(`https://glossarist.org/${register}/`);
+    }
+  });
+
+  it('records the concept count as an xsd:integer literal', () => {
+    const input = makeInput();
+    const graph = emitBuildActivityGraph(input);
+    const store = parse(writeTurtle(graph));
+    const iri = activityIri(input);
+    const counts = store.getObjects(iri, 'https://www.glossarist.org/ontologies/conceptCount', null).map(q => q.value);
+    expect(counts).toContain('1234');
+  });
+
+  it('associates the CI agent when provided', () => {
+    const input = makeInput();
+    const graph = emitBuildActivityGraph(input);
+    const store = parse(writeTurtle(graph));
+    const iri = activityIri(input);
+    const agents = store.getObjects(iri, expand('prov:wasAssociatedWith'), null).map(q => q.value);
+    expect(agents).toContain(input.associatedAgentIri);
+
+    const agentTypes = store.getObjects(input.associatedAgentIri!, expand('rdf:type'), null).map(q => q.value);
+    expect(agentTypes).toContain(expand('prov:Agent'));
+  });
+
+  it('omits the commit entity when gitSha is not provided', () => {
+    const input = makeInput({ gitSha: undefined, gitBranch: undefined });
+    const graph = emitBuildActivityGraph(input);
+    const store = parse(writeTurtle(graph));
+    const iri = activityIri(input);
+    const used = store.getObjects(iri, expand('prov:used'), null).map(q => q.value);
+    expect(used.some(u => u.includes('/commit/'))).toBe(false);
+  });
+});

package/src/__tests__/concept-rdf/coerce-date.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect } from 'vitest';
+import { Parser, Store } from 'n3';
+import { Concept } from 'glossarist';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import { emitConceptGraph } from '../../components/concept-rdf/concept-emitter';
+
+const G = 'https://www.glossarist.org/ontologies/';
+const XSD = 'http://www.w3.org/2001/XMLSchema#';
+
+function parse(turtle: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  return store;
+}
+
+const BASE = 'https://glossarist.org/fixtures/dates';
+
+describe('B4/C — coerceToDateTime handles year-only and month-only dates', () => {
+  it('coerces yyyy-mm-dd to xsd:dateTime unchanged (with T00:00:00Z)', () => {
+    const concept = Concept.fromJSON({
+      id: 'd.1', uri: `${BASE}/d.1`, status: 'valid',
+      dates: [{ type: 'accepted', date: '2020-06-15' }],
+      localizations: {
+        eng: {
+          language_code: 'eng', entry_status: 'valid',
+          terms: [{ type: 'expression', designation: 'd1', normative_status: 'preferred' }],
+          definition: [{ content: 'def' }],
+        },
+      },
+    });
+    const { graph } = emitConceptGraph(concept, concept.uri ?? '');
+    const store = parse(writeTurtle(graph));
+    const dateBlanks = store.getObjects(concept.uri ?? '', `${G}hasDate`, null);
+    const values = store.getObjects(dateBlanks[0], `${G}dateValue`, null);
+    expect((values[0] as any).value).toBe('2020-06-15T00:00:00Z');
+    expect((values[0] as any).datatype.value).toBe(`${XSD}dateTime`);
+  });
+
+  it('coerces year-only "2020" to "2020-01-01T00:00:00Z"', () => {
+    const concept = Concept.fromJSON({
+      id: 'd.2', uri: `${BASE}/d.2`, status: 'valid',
+      dates: [{ type: 'accepted', date: '2020' }],
+      localizations: {
+        eng: {
+          language_code: 'eng', entry_status: 'valid',
+          terms: [{ type: 'expression', designation: 'd2', normative_status: 'preferred' }],
+          definition: [{ content: 'def' }],
+        },
+      },
+    });
+    const { graph } = emitConceptGraph(concept, concept.uri ?? '');
+    const store = parse(writeTurtle(graph));
+    const dateBlanks = store.getObjects(concept.uri ?? '', `${G}hasDate`, null);
+    const values = store.getObjects(dateBlanks[0], `${G}dateValue`, null);
+    expect((values[0] as any).value).toBe('2020-01-01T00:00:00Z');
+    expect((values[0] as any).datatype.value).toBe(`${XSD}dateTime`);
+  });
+
+  it('coerces month-only "2020-06" to "2020-06-01T00:00:00Z"', () => {
+    const concept = Concept.fromJSON({
+      id: 'd.3', uri: `${BASE}/d.3`, status: 'valid',
+      dates: [{ type: 'accepted', date: '2020-06' }],
+      localizations: {
+        eng: {
+          language_code: 'eng', entry_status: 'valid',
+          terms: [{ type: 'expression', designation: 'd3', normative_status: 'preferred' }],
+          definition: [{ content: 'def' }],
+        },
+      },
+    });
+    const { graph } = emitConceptGraph(concept, concept.uri ?? '');
+    const store = parse(writeTurtle(graph));
+    const dateBlanks = store.getObjects(concept.uri ?? '', `${G}hasDate`, null);
+    const values = store.getObjects(dateBlanks[0], `${G}dateValue`, null);
+    expect((values[0] as any).value).toBe('2020-06-01T00:00:00Z');
+  });
+
+  it('passes through ISO 8601 datetimes unchanged', () => {
+    const concept = Concept.fromJSON({
+      id: 'd.4', uri: `${BASE}/d.4`, status: 'valid',
+      dates: [{ type: 'accepted', date: '2020-06-15T13:45:30Z' }],
+      localizations: {
+        eng: {
+          language_code: 'eng', entry_status: 'valid',
+          terms: [{ type: 'expression', designation: 'd4', normative_status: 'preferred' }],
+          definition: [{ content: 'def' }],
+        },
+      },
+    });
+    const { graph } = emitConceptGraph(concept, concept.uri ?? '');
+    const store = parse(writeTurtle(graph));
+    const dateBlanks = store.getObjects(concept.uri ?? '', `${G}hasDate`, null);
+    const values = store.getObjects(dateBlanks[0], `${G}dateValue`, null);
+    expect((values[0] as any).value).toBe('2020-06-15T13:45:30Z');
+  });
+});