sol-components 2.1.0

package/web/utils/feed-edit.js

@@ -0,0 +1,159 @@
+/**
+ * feed-edit.js — sol-feed's editing operations over a SKOS/DCAT feeds doc.
+ *
+ * Each operation is a *pure builder* returning `{ deletes, inserts }` arrays of
+ * Turtle triple strings; `patchDoc` turns one into a `application/sparql-update`
+ * body and PATCHes it to the feeds file (same-origin; no proxy — the CORS proxy
+ * is only for cross-origin RSS reads). Splitting build from send keeps the body
+ * construction unit-testable without a network.
+ *
+ * Model (matches libraries/news/feeds.ttl): topics are `skos:Concept`
+ * (`skos:prefLabel`, `skos:topConceptOf` the scheme); sources are
+ * `dcat:Dataset, rss:channel` with `dct:title` + `dcat:accessURL` +
+ * `dcat:theme` → a topic; the `dcat:Catalog` lists every source via
+ * `dcat:dataset`. Deleted sources are re-themed to a reserved `#Deleted`
+ * concept (NOT `topConceptOf` the scheme, so it never shows as a normal topic).
+ */
+
+export const NS = {
+  rdf:    'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+  dct:    'http://purl.org/dc/terms/',
+  dcat:   'http://www.w3.org/ns/dcat#',
+  skos:   'http://www.w3.org/2004/02/skos/core#',
+  rss:    'http://purl.org/rss/1.0/',
+  schema: 'http://schema.org/',
+};
+
+const DEFAULT_PREFIXES = {
+  rdf: NS.rdf, dct: NS.dct, dcat: NS.dcat, skos: NS.skos, rss: NS.rss, schema: NS.schema,
+};
+
+/** The reserved deleted-bin concept fragment. */
+export const BIN_FRAG = 'Deleted';
+export const binUriFor = (fileUri) => `${fileUri}#${BIN_FRAG}`;
+
+/** A Turtle string literal (handles quotes / backslashes / newlines). */
+export const lit = (s) => JSON.stringify(String(s));
+
+/* ── pure builders → { deletes, inserts } ───────────────────────────────── */
+
+export function renameTopicEdit(topicUri, oldLabel, newLabel) {
+  return {
+    deletes: [`<${topicUri}> skos:prefLabel ${lit(oldLabel)} .`],
+    inserts: [`<${topicUri}> skos:prefLabel ${lit(newLabel)} .`],
+  };
+}
+
+export function recategorizeEdit(feedUri, fromTopicUri, toTopicUri) {
+  if (fromTopicUri === toTopicUri) return { deletes: [], inserts: [] };
+  return {
+    deletes: [`<${feedUri}> dcat:theme <${fromTopicUri}> .`],
+    inserts: [`<${feedUri}> dcat:theme <${toTopicUri}> .`],
+  };
+}
+
+export function addFeedEdit(feedUri, { title, url, topicUri, catalogUri }) {
+  const inserts = [
+    `<${feedUri}> a dcat:Dataset, rss:channel ; ` +
+      `dct:title ${lit(title)} ; dcat:accessURL <${url}> ; dcat:theme <${topicUri}> .`,
+  ];
+  if (catalogUri) inserts.push(`<${catalogUri}> dcat:dataset <${feedUri}> .`);
+  return { deletes: [], inserts };
+}
+
+/** Move a source to the bin (re-theme to #Deleted), creating the bin concept
+ *  on first use. `binLabel` only matters when the concept is minted. */
+export function deleteToBinEdit(feedUri, fromTopicUri, binUri, { ensureBin = true, binLabel = 'Deleted' } = {}) {
+  const inserts = [`<${feedUri}> dcat:theme <${binUri}> .`];
+  if (ensureBin) inserts.push(`<${binUri}> a skos:Concept ; skos:prefLabel ${lit(binLabel)} .`);
+  return { deletes: [`<${feedUri}> dcat:theme <${fromTopicUri}> .`], inserts };
+}
+
+/** Restore from the bin = re-categorize out of #Deleted to a chosen topic. */
+export function restoreEdit(feedUri, binUri, toTopicUri) {
+  return recategorizeEdit(feedUri, binUri, toTopicUri);
+}
+
+/** Set/replace a single subject's ordering position. */
+export function reorderEdit(subjectUri, oldPos, newPos) {
+  const deletes = oldPos == null ? [] : [`<${subjectUri}> schema:position ${Number(oldPos)} .`];
+  return { deletes, inserts: [`<${subjectUri}> schema:position ${Number(newPos)} .`] };
+}
+
+/**
+ * Re-number a whole ordered list (a topic's sources). Writes `schema:position`
+ * 0..n-1 in the new order; only emits triples for items whose position changed.
+ * @param {string[]} orderedUris   subjects in their new order
+ * @param {Object<string,number>} [oldPos]  uri → its current position (if any)
+ */
+export function setPositionsEdit(orderedUris, oldPos = {}) {
+  const deletes = [], inserts = [];
+  orderedUris.forEach((uri, i) => {
+    const had = oldPos[uri];
+    if (had === i) return;                                  // already correct
+    if (had != null) deletes.push(`<${uri}> schema:position ${Number(had)} .`);
+    inserts.push(`<${uri}> schema:position ${i} .`);
+  });
+  return { deletes, inserts };
+}
+
+/* ── slug / mint ─────────────────────────────────────────────────────────── */
+
+/** Mint a unique `<fileUri>#feed-<slug>` not colliding with `existingUris`. */
+export function mintFeedUri(fileUri, title, existingUris = []) {
+  const taken = new Set(existingUris);
+  const base = 'feed-' + String(title).trim().toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40) || 'feed';
+  let frag = base, n = 2;
+  while (taken.has(`${fileUri}#${frag}`)) frag = `${base}-${n++}`;
+  return `${fileUri}#${frag}`;
+}
+
+/* ── serialise + send ────────────────────────────────────────────────────── */
+
+export function patchBody({ deletes = [], inserts = [] }, prefixes = DEFAULT_PREFIXES) {
+  const pfx = Object.entries(prefixes).map(([k, v]) => `PREFIX ${k}: <${v}>`).join('\n');
+  const block = (kw, triples) => `${kw} {\n${triples.map((t) => '  ' + t).join('\n')}\n}`;
+  const parts = [];
+  if (deletes.length) parts.push(block('DELETE DATA', deletes));
+  if (inserts.length) parts.push(block('INSERT DATA', inserts));
+  return `${pfx}\n${parts.join(' ;\n')}\n`;
+}
+
+/**
+ * PATCH the feeds file with one edit. Same-origin, no proxy.
+ * @param {string} fileUri
+ * @param {{deletes?:string[],inserts?:string[]}} edit
+ * @param {{prefixes?:object, fetchImpl?:Function}} [opts]
+ */
+export async function patchDoc(fileUri, edit, { prefixes = DEFAULT_PREFIXES, fetchImpl } = {}) {
+  if (!edit || (!edit.deletes?.length && !edit.inserts?.length)) return;
+  const f = fetchImpl || fetch;
+  const resp = await f(fileUri, {
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/sparql-update' },
+    body: patchBody(edit, prefixes),
+  });
+  if (!resp.ok) throw new Error(`Save failed (HTTP ${resp.status}) — the feeds file must be writable.`);
+}
+
+/**
+ * Permanent delete: remove ALL of a source's triples (DELETE … WHERE, so it
+ * works whatever predicates it has — title, accessURL, theme, position, …)
+ * plus its `dcat:dataset` catalog membership. Used to purge from the bin.
+ */
+export function purgeBody(feedUri, catalogUri, prefixes = DEFAULT_PREFIXES) {
+  const pfx = Object.entries(prefixes).map(([k, v]) => `PREFIX ${k}: <${v}>`).join('\n');
+  const cat = catalogUri ? `\n  <${catalogUri}> dcat:dataset <${feedUri}> .` : '';
+  return `${pfx}\nDELETE {\n  <${feedUri}> ?p ?o .${cat}\n} WHERE {\n  <${feedUri}> ?p ?o .\n}\n`;
+}
+
+export async function purgeFeed(fileUri, feedUri, { catalogUri, prefixes, fetchImpl } = {}) {
+  const f = fetchImpl || fetch;
+  const resp = await f(fileUri, {
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/sparql-update' },
+    body: purgeBody(feedUri, catalogUri, prefixes),
+  });
+  if (!resp.ok) throw new Error(`Permanent delete failed (HTTP ${resp.status}).`);
+}

package/web/utils/feed-edit.smoke.mjs

@@ -0,0 +1,74 @@
+import assert from 'node:assert';
+import {
+  renameTopicEdit, recategorizeEdit, addFeedEdit, deleteToBinEdit, restoreEdit,
+  reorderEdit, mintFeedUri, patchBody, patchDoc, binUriFor, lit,
+} from './feed-edit.js';
+
+let n = 0; const ok = (m) => { console.log('  ✓ ' + m); n++; };
+const F = 'http://ex/feeds.ttl';
+
+// rename
+let e = renameTopicEdit(F+'#News', 'News', 'World News');
+assert.deepEqual(e.deletes, [`<${F}#News> skos:prefLabel "News" .`]);
+assert.deepEqual(e.inserts, [`<${F}#News> skos:prefLabel "World News" .`]);
+ok('renameTopicEdit swaps prefLabel');
+
+// recategorize + no-op
+e = recategorizeEdit(F+'#f1', F+'#News', F+'#Culture');
+assert.ok(e.deletes[0].includes('#News') && e.inserts[0].includes('#Culture'));
+assert.deepEqual(recategorizeEdit(F+'#f1', F+'#News', F+'#News'), {deletes:[],inserts:[]});
+ok('recategorizeEdit moves dcat:theme (no-op when unchanged)');
+
+// add (with + without catalog)
+e = addFeedEdit(F+'#feed-x', { title:'X "Y"', url:'http://x/r.xml', topicUri:F+'#News', catalogUri:F+'#catalog' });
+assert.ok(e.inserts[0].includes('a dcat:Dataset, rss:channel'));
+assert.ok(e.inserts[0].includes('dct:title "X \\"Y\\""'));      // quote escaped
+assert.ok(e.inserts[0].includes('dcat:accessURL <http://x/r.xml>'));
+assert.equal(e.inserts[1], `<${F}#catalog> dcat:dataset <${F}#feed-x> .`);
+ok('addFeedEdit builds dataset + catalog membership, escapes literals');
+
+// delete → bin (ensures bin concept)
+const bin = binUriFor(F);
+assert.equal(bin, F+'#Deleted');
+e = deleteToBinEdit(F+'#f1', F+'#News', bin);
+assert.deepEqual(e.deletes, [`<${F}#f1> dcat:theme <${bin}> .`].map(()=>`<${F}#f1> dcat:theme <${F}#News> .`));
+assert.ok(e.inserts.some(t => t === `<${F}#f1> dcat:theme <${bin}> .`));
+assert.ok(e.inserts.some(t => t.includes('skos:Concept') && t.includes('"Deleted"')));
+ok('deleteToBinEdit re-themes to #Deleted and mints the bin concept');
+
+// restore = recategorize out of bin
+e = restoreEdit(F+'#f1', bin, F+'#Culture');
+assert.ok(e.deletes[0].includes('#Deleted') && e.inserts[0].includes('#Culture'));
+ok('restoreEdit re-files out of the bin');
+
+// reorder
+e = reorderEdit(F+'#f1', 3, 7);
+assert.deepEqual(e.deletes, [`<${F}#f1> schema:position 3 .`]);
+assert.deepEqual(e.inserts, [`<${F}#f1> schema:position 7 .`]);
+ok('reorderEdit replaces schema:position');
+
+// mint uniqueness
+assert.equal(mintFeedUri(F, 'NY Times', []), F+'#feed-ny-times');
+assert.equal(mintFeedUri(F, 'NY Times', [F+'#feed-ny-times']), F+'#feed-ny-times-2');
+ok('mintFeedUri slugifies + avoids collisions');
+
+// patchBody both sections + prefixes
+const body = patchBody(recategorizeEdit(F+'#f1', F+'#News', F+'#Culture'));
+assert.ok(body.includes('PREFIX dcat: <http://www.w3.org/ns/dcat#>'));
+assert.ok(body.includes('DELETE DATA {') && body.includes('INSERT DATA {') && body.includes(' ;\n'));
+assert.ok(patchBody({inserts:['<a> <b> <c> .']}).includes('INSERT DATA') && !patchBody({inserts:['<a> <b> <c> .']}).includes('DELETE'));
+ok('patchBody emits prefixes + DELETE/INSERT DATA blocks');
+
+// patchDoc wiring (fake fetch) + no-op skip
+let captured = null;
+await patchDoc(F, recategorizeEdit(F+'#f1', F+'#News', F+'#Culture'), { fetchImpl: async (u, o) => { captured = {u,o}; return {ok:true}; } });
+assert.equal(captured.u, F);
+assert.equal(captured.o.method, 'PATCH');
+assert.equal(captured.o.headers['Content-Type'], 'application/sparql-update');
+let called = false;
+await patchDoc(F, {deletes:[],inserts:[]}, { fetchImpl: async () => { called = true; return {ok:true}; } });
+assert.equal(called, false, 'no-op edit does not PATCH');
+await assert.rejects(() => patchDoc(F, recategorizeEdit(F+'#f1',F+'#a',F+'#b'), { fetchImpl: async()=>({ok:false,status:403}) }), /403/);
+ok('patchDoc PATCHes sparql-update, skips no-ops, throws on !ok');
+
+console.log(`\n${n} feed-edit checks passed`);