/**

* N3 Patch Parser and Applier

*

* Implements Solid's N3 Patch format for updating RDF resources.

* https://solid.github.io/specification/protocol#n3-patch

*

* Supported format:

* @prefix solid: <http://www.w3.org/ns/solid/terms#>.

* _:patch a solid:InsertDeletePatch;

* solid:inserts { <subject> <predicate> "object" };

* solid:deletes { <subject> <predicate> "old" }.

*/

const SOLID_NS = 'http://www.w3.org/ns/solid/terms#';

/**

* Parse an N3 Patch document

* @param {string} patchText - The N3 patch content

* @param {string} baseUri - Base URI for resolving relative references

* @returns {{inserts: Array, deletes: Array, where: Array}}

*/

export function parseN3Patch(patchText, baseUri) {

const result = {

inserts: [],

deletes: [],

where: []

};

// Extract prefixes

const prefixes = {};

const prefixRegex = /@prefix\s+(\w*):?\s*<([^>]+)>\s*\./g;

let match;

while ((match = prefixRegex.exec(patchText)) !== null) {

prefixes[match[1]] = match[2];

}

// Find solid:inserts block

const insertsMatch = patchText.match(/solid:inserts\s*\{([^}]*)\}/s);

if (insertsMatch) {

result.inserts = parseTriples(insertsMatch[1], prefixes, baseUri);

}

// Find solid:deletes block

const deletesMatch = patchText.match(/solid:deletes\s*\{([^}]*)\}/s);

if (deletesMatch) {

result.deletes = parseTriples(deletesMatch[1], prefixes, baseUri);

}

// Find solid:where block (for conditions - simplified support)

const whereMatch = patchText.match(/solid:where\s*\{([^}]*)\}/s);

if (whereMatch) {

result.where = parseTriples(whereMatch[1], prefixes, baseUri);

}

return result;

}

/**

* Parse triples from N3 block content

* Handles Turtle semicolon shorthand (same subject, different predicate-object)

*/

function parseTriples(content, prefixes, baseUri) {

const triples = [];

// Clean up content

content = content.trim();

if (!content) return triples;

// Split by '.' but be careful with strings containing '.'

const statements = splitStatements(content);

let lastSubject = null;

for (const stmt of statements) {

const trimmed = stmt.trim();

if (!trimmed) continue;

const tokens = tokenize(trimmed);

if (tokens.length < 2) continue;

let subject, predicate, object;

if (tokens.length >= 3) {

// Full triple: subject predicate object

subject = resolveValue(tokens[0], prefixes, baseUri);

predicate = resolveValue(tokens[1], prefixes, baseUri);

object = resolveValue(tokens.slice(2).join(' '), prefixes, baseUri);

lastSubject = subject;

} else if (tokens.length === 2 && lastSubject) {

// Semicolon continuation: predicate object (reuse last subject)

subject = lastSubject;

predicate = resolveValue(tokens[0], prefixes, baseUri);

object = resolveValue(tokens[1], prefixes, baseUri);

} else {

continue;

}

// Handle 'a' as rdf:type

if (predicate === 'a') {

predicate = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';

}

triples.push({ subject, predicate, object });

}

return triples;

}

/**

* Split content into statements (handling quoted strings)

*/

function splitStatements(content) {

const statements = [];

let current = '';

let inString = false;

let stringChar = null;

let inIri = false;

for (let i = 0; i < content.length; i++) {

const char = content[i];

if (!inString && !inIri && char === '<') {

inIri = true;

current += char;

} else if (inIri && char === '>') {

inIri = false;

current += char;

} else if (!inIri && !inString && (char === '"' || char === "'")) {

inString = true;

stringChar = char;

current += char;

} else if (inString && char === stringChar && content[i - 1] !== '\\') {

inString = false;

stringChar = null;

current += char;

} else if (!inString && !inIri && char === '.') {

if (current.trim()) {

statements.push(current);

}

current = '';

} else if (!inString && !inIri && char === ';') {

// Turtle shorthand - same subject, different predicate

if (current.trim()) {

statements.push(current);

}

current = '';

} else {

current += char;

}

}

if (current.trim()) {

statements.push(current);

}

return statements;

}

/**

* Tokenize a statement respecting quoted strings

*/

function tokenize(stmt) {

const tokens = [];

let current = '';

let inString = false;

let stringChar = null;

for (let i = 0; i < stmt.length; i++) {

const char = stmt[i];

if (!inString && (char === '"' || char === "'")) {

inString = true;

stringChar = char;

current += char;

} else if (inString && char === stringChar && stmt[i - 1] !== '\\') {

inString = false;

stringChar = null;

current += char;

} else if (!inString && /\s/.test(char)) {

if (current) {

tokens.push(current);

current = '';

}

} else {

current += char;

}

}

if (current) {

tokens.push(current);

}

return tokens;

}

/**

* Resolve a value (URI, prefixed name, or literal)

*/

function resolveValue(value, prefixes, baseUri) {

value = value.trim();

// Full URI

if (value.startsWith('<') && value.endsWith('>')) {

const uri = value.slice(1, -1);

// Resolve relative URIs

if (!uri.includes('://') && !uri.startsWith('#')) {

return new URL(uri, baseUri).href;

}

if (uri.startsWith('#')) {

return baseUri + uri;

}

return uri;

}

// Prefixed name

if (value.includes(':') && !value.startsWith('"')) {

const [prefix, local] = value.split(':', 2);

if (prefixes[prefix]) {

return prefixes[prefix] + local;

}

// Common prefixes

const commonPrefixes = {

'solid': SOLID_NS,

'rdf': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',

'rdfs': 'http://www.w3.org/2000/01/rdf-schema#',

'foaf': 'http://xmlns.com/foaf/0.1/',

'dc': 'http://purl.org/dc/terms/',

'schema': 'http://schema.org/',

'ldp': 'http://www.w3.org/ns/ldp#'

};

if (commonPrefixes[prefix]) {

return commonPrefixes[prefix] + local;

}

}

// String literal

if (value.startsWith('"')) {

// Handle typed literals "value"^^<type>

const typedMatch = value.match(/^"(.*)"\^\^<([^>]+)>$/);

if (typedMatch) {

return { value: typedMatch[1], type: typedMatch[2] };

}

// Handle language tags "value"@en

const langMatch = value.match(/^"(.*)"@(\w+)$/);

if (langMatch) {

return { value: langMatch[1], language: langMatch[2] };

}

// Plain string

const plainMatch = value.match(/^"(.*)"$/);

if (plainMatch) {

return plainMatch[1];

}

}

// Variable (for WHERE patterns)

if (value.startsWith('?')) {

return { variable: value.slice(1) };

}

// Blank node

if (value.startsWith('_:')) {

return { blankNode: value.slice(2) };

}

return value;

}

/**

* Apply an N3 Patch to a JSON-LD document

* @param {object} document - The JSON-LD document

* @param {object} patch - Parsed patch {inserts, deletes}

* @param {string} baseUri - Base URI of the document

* @returns {object} Updated JSON-LD document

*/

export function applyN3Patch(document, patch, baseUri) {

// Clone the document

let doc = JSON.parse(JSON.stringify(document));

// Handle @graph array or single object

const isGraph = Array.isArray(doc['@graph']);

let nodes = isGraph ? doc['@graph'] : [doc];

// Apply deletes first

for (const triple of patch.deletes) {

nodes = deleteTriple(nodes, triple, baseUri);

}

// Then apply inserts

for (const triple of patch.inserts) {

nodes = insertTriple(nodes, triple, baseUri);

}

// Reconstruct document

if (isGraph) {

doc['@graph'] = nodes;

} else {

doc = nodes[0] || doc;

}

return doc;

}

/**

* Delete a triple from JSON-LD nodes

*/

function deleteTriple(nodes, triple, baseUri) {

const { subject, predicate, object } = triple;

for (const node of nodes) {

const nodeId = node['@id'] || '';

const resolvedNodeId = nodeId.startsWith('#') ? baseUri + nodeId : nodeId;

// Check if this node matches the subject

if (resolvedNodeId === subject || nodeId === subject) {

// Find the predicate

for (const key of Object.keys(node)) {

if (key.startsWith('@')) continue;

// Check if key matches predicate (could be full URI or prefixed)

if (key === predicate || expandPredicate(key) === predicate) {

const values = Array.isArray(node[key]) ? node[key] : [node[key]];

const newValues = values.filter(v => !valueMatches(v, object));

if (newValues.length === 0) {

delete node[key];

} else if (newValues.length === 1) {

node[key] = newValues[0];

} else {

node[key] = newValues;

}

}

}

}

}

return nodes;

}

/**

* Insert a triple into JSON-LD nodes

*/

function insertTriple(nodes, triple, baseUri) {

const { subject, predicate, object } = triple;

// Find or create the subject node

let subjectNode = nodes.find(n => {

const nodeId = n['@id'] || '';

const resolvedNodeId = nodeId.startsWith('#') ? baseUri + nodeId : nodeId;

return resolvedNodeId === subject || nodeId === subject;

});

if (!subjectNode) {

// Create new node

subjectNode = { '@id': subject };

nodes.push(subjectNode);

}

// Add the predicate-object

const predicateKey = compactPredicate(predicate);

const objectValue = convertToJsonLd(object);

if (subjectNode[predicateKey]) {

// Add to existing values

const existing = Array.isArray(subjectNode[predicateKey])

? subjectNode[predicateKey]

: [subjectNode[predicateKey]];

// Check if value already exists

if (!existing.some(v => valueMatches(v, object))) {

subjectNode[predicateKey] = [...existing, objectValue];

}

} else {

subjectNode[predicateKey] = objectValue;

}

return nodes;

}

/**

* Check if a JSON-LD value matches an N3 object

*/

function valueMatches(jsonLdValue, n3Object) {

// Handle null/undefined

if (jsonLdValue === null || jsonLdValue === undefined) {

return false;

}

// Number comparison - N3 numbers may come as strings

if (typeof jsonLdValue === 'number') {

if (typeof n3Object === 'number') {

return jsonLdValue === n3Object;

}

if (typeof n3Object === 'string') {

return jsonLdValue === parseFloat(n3Object) || jsonLdValue.toString() === n3Object;

}

}

// String comparison

if (typeof jsonLdValue === 'string' && typeof n3Object === 'string') {

return jsonLdValue === n3Object;

}

// @id comparison

if (jsonLdValue && jsonLdValue['@id']) {

return jsonLdValue['@id'] === n3Object;

}

// @value comparison

if (jsonLdValue && jsonLdValue['@value']) {

if (typeof n3Object === 'object' && n3Object.value) {

return jsonLdValue['@value'] === n3Object.value;

}

return jsonLdValue['@value'] === n3Object;

}

// Direct equality (for booleans, numbers parsed as numbers, etc.)

return jsonLdValue === n3Object || String(jsonLdValue) === String(n3Object);

}

/**

* Convert N3 object to JSON-LD value

*/

function convertToJsonLd(object) {

if (typeof object === 'string') {

// Check if it's a URI

if (object.startsWith('http://') || object.startsWith('https://')) {

return { '@id': object };

}

return object;

}

if (typeof object === 'object') {

if (object.value && object.type) {

return { '@value': object.value, '@type': object.type };

}

if (object.value && object.language) {

return { '@value': object.value, '@language': object.language };

}

if (object.value) {

return object.value;

}

}

return object;

}

/**

* Expand a potentially prefixed predicate to full URI

*/

function expandPredicate(predicate) {

const commonPrefixes = {

'solid': SOLID_NS,

'rdf': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',

'rdfs': 'http://www.w3.org/2000/01/rdf-schema#',

'foaf': 'http://xmlns.com/foaf/0.1/',

'dc': 'http://purl.org/dc/terms/',

'schema': 'http://schema.org/',

'ldp': 'http://www.w3.org/ns/ldp#'

};

if (predicate.includes(':')) {

const [prefix, local] = predicate.split(':', 2);

if (commonPrefixes[prefix]) {

return commonPrefixes[prefix] + local;

}

}

return predicate;

}

/**

* Compact a full URI predicate to prefixed form if possible

*/

function compactPredicate(predicate) {

const prefixMap = {

[SOLID_NS]: 'solid:',

'http://www.w3.org/1999/02/22-rdf-syntax-ns#': 'rdf:',

'http://www.w3.org/2000/01/rdf-schema#': 'rdfs:',

'http://xmlns.com/foaf/0.1/': 'foaf:',

'http://purl.org/dc/terms/': 'dc:',

'http://schema.org/': 'schema:',

'http://www.w3.org/ns/ldp#': 'ldp:'

};

for (const [uri, prefix] of Object.entries(prefixMap)) {

if (predicate.startsWith(uri)) {

return prefix + predicate.slice(uri.length);

}

}

return predicate;

}

/**

* Validate that a patch can be applied

* @param {object} document - The JSON-LD document

* @param {object} patch - Parsed patch

* @param {string} baseUri - Base URI

* @returns {{valid: boolean, error: string|null}}

*/

export function validatePatch(document, patch, baseUri) {

// Check that all deletes exist in the document

for (const triple of patch.deletes) {

if (!tripleExists(document, triple, baseUri)) {

return {

valid: false,

error: `Triple to delete not found: ${JSON.stringify(triple)}`

};

}

}

return { valid: true, error: null };

}

/**

* Check if a triple exists in a document

*/

function tripleExists(document, triple, baseUri) {

const nodes = document['@graph'] || [document];

const { subject, predicate, object } = triple;

for (const node of nodes) {

const nodeId = node['@id'] || '';

const resolvedNodeId = nodeId.startsWith('#') ? baseUri + nodeId : nodeId;

if (resolvedNodeId === subject || nodeId === subject) {

for (const key of Object.keys(node)) {

if (key.startsWith('@')) continue;

if (key === predicate || expandPredicate(key) === predicate) {

const values = Array.isArray(node[key]) ? node[key] : [node[key]];

if (values.some(v => valueMatches(v, object))) {

return true;

}

}

}

}

}

return false;

}