@undefineds.co/xpod 0.1.0-local.202602081751

package/dist/storage/RepresentationPartialConvertingStore.jsonld

@@ -0,0 +1,332 @@
+{
+  "@context": [
+    "https://linkedsoftwaredependencies.org/bundles/npm/@undefineds.co/xpod/^0.0.0/components/context.jsonld",
+    "https://linkedsoftwaredependencies.org/bundles/npm/@solid/community-server/^8.0.0/components/context.jsonld"
+  ],
+  "@id": "npmd:@undefineds.co/xpod",
+  "components": [
+    {
+      "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore",
+      "@type": "Class",
+      "requireElement": "RepresentationPartialConvertingStore",
+      "extends": [
+        {
+          "@type": "GenericComponentExtension",
+          "component": "css:dist/storage/PassthroughStore.jsonld#PassthroughStore",
+          "genericTypeInstances": [
+            {
+              "@type": "ParameterRangeGenericTypeReference",
+              "parameterRangeGenericType": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore__generic_T"
+            }
+          ]
+        }
+      ],
+      "comment": "A store that converts representations based on their content type.",
+      "genericTypeParameters": [
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore__generic_T",
+          "range": "css:dist/storage/ResourceStore.jsonld#ResourceStore",
+          "default": "css:dist/storage/ResourceStore.jsonld#ResourceStore"
+        }
+      ],
+      "parameters": [
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_source",
+          "range": {
+            "@type": "ParameterRangeGenericTypeReference",
+            "parameterRangeGenericType": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore__generic_T"
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_metadataStrategy",
+          "range": "css:dist/http/auxiliary/AuxiliaryStrategy.jsonld#AuxiliaryStrategy"
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_outConverter",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              "css:dist/storage/conversion/RepresentationConverter.jsonld#RepresentationConverter",
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inConverter",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              "css:dist/storage/conversion/RepresentationConverter.jsonld#RepresentationConverter",
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_type",
+          "range": {
+            "@type": "ParameterRangeCollectEntries",
+            "parameterRangeCollectEntriesParameters": [
+              {
+                "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_type_key"
+              },
+              {
+                "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_type_value",
+                "range": "xsd:number"
+              }
+            ]
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_charset",
+          "range": {
+            "@type": "ParameterRangeCollectEntries",
+            "parameterRangeCollectEntriesParameters": [
+              {
+                "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_charset_key"
+              },
+              {
+                "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_charset_value",
+                "range": "xsd:number"
+              }
+            ]
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_datetime",
+          "range": {
+            "@type": "ParameterRangeCollectEntries",
+            "parameterRangeCollectEntriesParameters": [
+              {
+                "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_datetime_key"
+              },
+              {
+                "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_datetime_value",
+                "range": "xsd:number"
+              }
+            ]
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_encoding",
+          "range": {
+            "@type": "ParameterRangeCollectEntries",
+            "parameterRangeCollectEntriesParameters": [
+              {
+                "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_encoding_key"
+              },
+              {
+                "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_encoding_value",
+                "range": "xsd:number"
+              }
+            ]
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_language",
+          "range": {
+            "@type": "ParameterRangeCollectEntries",
+            "parameterRangeCollectEntriesParameters": [
+              {
+                "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_language_key"
+              },
+              {
+                "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_language_value",
+                "range": "xsd:number"
+              }
+            ]
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_range_unit",
+          "range": "xsd:string"
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_range_parts",
+          "range": {
+            "@type": "ParameterRangeArray",
+            "parameterRangeValue": {
+              "@type": "ParameterRangeWildcard"
+            }
+          }
+        }
+      ],
+      "memberFields": [
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore__member_logger",
+          "memberFieldName": "logger",
+          "range": {
+            "@type": "ParameterRangeWildcard"
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore__member_metadataStrategy",
+          "memberFieldName": "metadataStrategy"
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore__member_inConverter",
+          "memberFieldName": "inConverter"
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore__member_outConverter",
+          "memberFieldName": "outConverter"
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore__member_inPreferences",
+          "memberFieldName": "inPreferences"
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore__member_constructor",
+          "memberFieldName": "constructor"
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore__member_shouldConvert",
+          "memberFieldName": "shouldConvert"
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore__member_getRepresentation",
+          "memberFieldName": "getRepresentation"
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore__member_addResource",
+          "memberFieldName": "addResource"
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore__member_setRepresentation",
+          "memberFieldName": "setRepresentation"
+        }
+      ],
+      "constructorArguments": [
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_source"
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_metadataStrategy"
+        },
+        {
+          "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options__constructorArgument",
+          "fields": [
+            {
+              "keyRaw": "outConverter",
+              "value": {
+                "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_outConverter"
+              }
+            },
+            {
+              "keyRaw": "inConverter",
+              "value": {
+                "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inConverter"
+              }
+            },
+            {
+              "keyRaw": "inPreferences",
+              "value": {
+                "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences__constructorArgument",
+                "fields": [
+                  {
+                    "keyRaw": "type",
+                    "value": {
+                      "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_type__constructorArgument",
+                      "fields": [
+                        {
+                          "collectEntries": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_type",
+                          "key": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_type_key",
+                          "value": {
+                            "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_type_value"
+                          }
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    "keyRaw": "charset",
+                    "value": {
+                      "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_charset__constructorArgument",
+                      "fields": [
+                        {
+                          "collectEntries": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_charset",
+                          "key": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_charset_key",
+                          "value": {
+                            "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_charset_value"
+                          }
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    "keyRaw": "datetime",
+                    "value": {
+                      "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_datetime__constructorArgument",
+                      "fields": [
+                        {
+                          "collectEntries": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_datetime",
+                          "key": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_datetime_key",
+                          "value": {
+                            "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_datetime_value"
+                          }
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    "keyRaw": "encoding",
+                    "value": {
+                      "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_encoding__constructorArgument",
+                      "fields": [
+                        {
+                          "collectEntries": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_encoding",
+                          "key": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_encoding_key",
+                          "value": {
+                            "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_encoding_value"
+                          }
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    "keyRaw": "language",
+                    "value": {
+                      "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_language__constructorArgument",
+                      "fields": [
+                        {
+                          "collectEntries": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_language",
+                          "key": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_language_key",
+                          "value": {
+                            "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_language_value"
+                          }
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    "keyRaw": "range",
+                    "value": {
+                      "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_range__constructorArgument",
+                      "fields": [
+                        {
+                          "keyRaw": "unit",
+                          "value": {
+                            "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_range_unit"
+                          }
+                        },
+                        {
+                          "keyRaw": "parts",
+                          "value": {
+                            "@id": "undefineds:dist/storage/RepresentationPartialConvertingStore.jsonld#RepresentationPartialConvertingStore_options_inPreferences_range_parts"
+                          }
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

package/dist/storage/SparqlUpdateResourceStore.d.ts

@@ -0,0 +1,30 @@
+import { DataAccessorBasedStore, type ChangeMap, type ResourceIdentifier, type Patch, type Conditions, type DataAccessor, type IdentifierStrategy, type AuxiliaryStrategy, type Representation } from '@solid/community-server';
+export interface SparqlUpdateResourceStoreOptions {
+    accessor: DataAccessor;
+    identifierStrategy: IdentifierStrategy;
+    auxiliaryStrategy: AuxiliaryStrategy;
+    metadataStrategy: AuxiliaryStrategy;
+}
+/**
+ * ResourceStore that short-circuits PATCH into direct SPARQL UPDATE
+ * when the underlying DataAccessor supports it.
+ */
+export declare class SparqlUpdateResourceStore extends DataAccessorBasedStore {
+    private readonly generator;
+    private readonly parser;
+    protected readonly logger: import("global-logger-factory").Logger<unknown>;
+    constructor(options: SparqlUpdateResourceStoreOptions);
+    modifyResource(identifier: ResourceIdentifier, patch: Patch, conditions?: Conditions): Promise<ChangeMap>;
+    /**
+     * 只处理 SPARQL UPDATE (application/sparql-update)。
+     * N3 Patch 和其他类型返回 undefined，让 CSS PatchingStore 回退到 get-patch-set 逻辑。
+     */
+    private toSparqlUpdate;
+    /**
+     * Ensure SPARQL UPDATE targets the resource graph (CSS stores documents in named graphs).
+     */
+    private normalizeGraphs;
+    private isSparqlUpdatePatch;
+    private isSparqlCapable;
+    setRepresentation(identifier: ResourceIdentifier, representation: Representation, conditions?: Conditions): Promise<ChangeMap>;
+}

package/dist/storage/SparqlUpdateResourceStore.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SparqlUpdateResourceStore = void 0;
+const n3_1 = require("n3");
+const sparqljs_1 = require("sparqljs");
+const community_server_1 = require("@solid/community-server");
+const StreamUtil_1 = require("@solid/community-server/dist/util/StreamUtil");
+const global_logger_factory_1 = require("global-logger-factory");
+/**
+ * ResourceStore that short-circuits PATCH into direct SPARQL UPDATE
+ * when the underlying DataAccessor supports it.
+ */
+class SparqlUpdateResourceStore extends community_server_1.DataAccessorBasedStore {
+    constructor(options) {
+        super(options.accessor, options.identifierStrategy, options.auxiliaryStrategy, options.metadataStrategy);
+        this.generator = new sparqljs_1.Generator();
+        this.parser = new sparqljs_1.Parser();
+        this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
+        // Check if identifierStrategy has baseUrl property (SingleRootIdentifierStrategy)
+        const strategy = options.identifierStrategy;
+        this.logger.info(`SparqlUpdateResourceStore initialized with identifierStrategy: ${options.identifierStrategy.constructor.name}, baseUrl: ${strategy.baseUrl ?? 'N/A'}`);
+    }
+    // @ts-expect-error Upstream signature returns never; we return ChangeMap for successful PATCH.
+    async modifyResource(identifier, patch, conditions) {
+        this.logger.debug(`SparqlUpdateResourceStore.modifyResource called for ${identifier.path}`);
+        this.logger.debug(`Patch has algebra: ${typeof patch.algebra === 'object'}, metadata.contentType: ${patch.metadata?.contentType}`);
+        const accessor = this.accessor;
+        if (!this.isSparqlCapable(accessor)) {
+            this.logger.debug('Accessor is not SPARQL capable');
+            throw new community_server_1.NotImplementedHttpError('SPARQL UPDATE not supported by this accessor');
+        }
+        // Keep the default condition validation semantics
+        if (conditions) {
+            let metadata;
+            try {
+                metadata = await accessor.getMetadata(identifier);
+            }
+            catch (error) {
+                if (!community_server_1.NotFoundHttpError.isInstance(error)) {
+                    throw error;
+                }
+            }
+            this.validateConditions(conditions, metadata);
+        }
+        const sparqlUpdate = await this.toSparqlUpdate(patch, identifier);
+        if (!sparqlUpdate) {
+            this.logger.debug(`toSparqlUpdate returned undefined for ${identifier.path}, falling back to CSS handler`);
+            throw new community_server_1.NotImplementedHttpError('Unsupported PATCH payload for SPARQL conversion');
+        }
+        this.logger.debug(`Applying SPARQL PATCH to ${identifier.path}: ${sparqlUpdate}`);
+        await accessor.executeSparqlUpdate(sparqlUpdate, identifier.path);
+        // PATCH does not affect containment; mark the target resource as updated.
+        const changes = new community_server_1.IdentifierMap();
+        changes.set(identifier, new community_server_1.RepresentationMetadata(identifier, { [community_server_1.SOLID_AS.activity]: community_server_1.AS.terms.Update }));
+        return changes;
+    }
+    /**
+     * 只处理 SPARQL UPDATE (application/sparql-update)。
+     * N3 Patch 和其他类型返回 undefined，让 CSS PatchingStore 回退到 get-patch-set 逻辑。
+     */
+    async toSparqlUpdate(patch, identifier) {
+        // 只处理 SPARQL UPDATE，其他类型（包括 N3 Patch）回退到 CSS 默认处理
+        if (!this.isSparqlUpdatePatch(patch)) {
+            return undefined;
+        }
+        const updateText = await (0, StreamUtil_1.readableToString)(patch.data);
+        return this.normalizeGraphs(updateText, identifier);
+    }
+    /**
+     * Ensure SPARQL UPDATE targets the resource graph (CSS stores documents in named graphs).
+     */
+    normalizeGraphs(updateText, identifier) {
+        const graph = n3_1.DataFactory.namedNode(identifier.path);
+        const identifierStrategy = this.identifierStrategy;
+        const assertGraphAllowed = (value) => {
+            if (!value || typeof value !== 'object') {
+                return;
+            }
+            const term = value;
+            if (term.termType === 'NamedNode' && term.value && !identifierStrategy.supportsIdentifier({ path: term.value })) {
+                throw new community_server_1.BadRequestHttpError(`GRAPH ${term.value} is outside the configured identifier space.`);
+            }
+        };
+        const wrapDefaultGraph = (text) => {
+            const insert = /INSERT\s+DATA\s*{\s*([^}]*)}/is;
+            const del = /DELETE\s+DATA\s*{\s*([^}]*)}/is;
+            const rewrite = (regex, label, input) => input.replace(regex, (_match, body) => `${label} { GRAPH <${graph.value}> { ${body} } }`);
+            let out = text;
+            if (insert.test(out)) {
+                out = rewrite(insert, 'INSERT DATA', out);
+            }
+            if (del.test(out)) {
+                out = rewrite(del, 'DELETE DATA', out);
+            }
+            return out;
+        };
+        const rewriteTriples = (triples, targetGraph = graph) => {
+            if (!triples)
+                return [];
+            return triples.map((triple) => ({
+                ...triple,
+                graph: (!triple.graph || triple.graph.termType === 'DefaultGraph') ? targetGraph : triple.graph,
+            }));
+        };
+        const rewritePattern = (pattern) => {
+            if (pattern.type === 'bgp') {
+                return { ...pattern, triples: rewriteTriples(pattern.triples) };
+            }
+            if (pattern.type === 'graph') {
+                return { ...pattern, patterns: pattern.patterns?.map(rewritePattern) ?? [] };
+            }
+            if (pattern.type === 'group') {
+                return { ...pattern, patterns: pattern.patterns?.map(rewritePattern) ?? [] };
+            }
+            if (pattern.type === 'optional') {
+                return { ...pattern, patterns: pattern.patterns?.map(rewritePattern) ?? [] };
+            }
+            if (pattern.type === 'union') {
+                return { ...pattern, patterns: pattern.patterns?.map(rewritePattern) ?? [] };
+            }
+            if (pattern.type === 'minus') {
+                return { ...pattern, patterns: pattern.patterns?.map(rewritePattern) ?? [] };
+            }
+            if (pattern.type === 'filter') {
+                return pattern; // FILTER doesn't contain triples, pass through
+            }
+            if (pattern.type === 'bind') {
+                return pattern; // BIND doesn't contain triples, pass through
+            }
+            if (pattern.type === 'values') {
+                return pattern; // VALUES doesn't contain triples, pass through
+            }
+            if (pattern.type === 'service') {
+                return { ...pattern, patterns: pattern.patterns?.map(rewritePattern) ?? [] };
+            }
+            return pattern;
+        };
+        const toGraphQuads = (items) => {
+            if (!items)
+                return items;
+            return items.map((item) => {
+                if (item?.type === 'graph') {
+                    assertGraphAllowed(item.name);
+                    return {
+                        ...item,
+                        name: item.name ?? graph,
+                        triples: rewriteTriples(item.triples, item.name ?? graph),
+                    };
+                }
+                // Treat as plain quad
+                return {
+                    type: 'graph',
+                    name: graph,
+                    triples: rewriteTriples([item], graph),
+                };
+            });
+        };
+        try {
+            console.log(`[normalizeGraphs] Input SPARQL (first 500 chars): ${updateText.slice(0, 500)}`);
+            const parsed = this.parser.parse(updateText);
+            // Explicitly reject SPARQL Queries (SELECT, ASK, CONSTRUCT) in PATCH
+            if (parsed.type === 'query') {
+                this.logger.warn(`Received SPARQL Query in PATCH request for ${identifier.path}. SPARQL PATCH only supports UPDATE operations.`);
+                return undefined;
+            }
+            const collect = (ops, key) => ops.flatMap((op) => {
+                const entries = op[key];
+                if (!entries)
+                    return [];
+                if (Array.isArray(entries)) {
+                    return entries.flatMap((entry) => entry.triples ? entry.triples : (entry.quads ?? []));
+                }
+                return [];
+            });
+            const deleteTriples = collect(parsed.updates, 'delete');
+            const insertTriples = collect(parsed.updates, 'insert');
+            const hasVariables = [...deleteTriples, ...insertTriples].some((t) => t.subject?.termType === 'Variable' || t.predicate?.termType === 'Variable' || t.object?.termType === 'Variable');
+            const simpleOps = parsed.updates.every((op) => ['delete', 'insert', 'insertdelete', 'deleteinsert'].includes(op.updateType) &&
+                (!op.where || op.where.length === 0) &&
+                !hasVariables);
+            this.logger.debug(`[normalizeGraphs] simpleOps=${simpleOps}, hasVariables=${hasVariables}, deleteTriples=${deleteTriples.length}, insertTriples=${insertTriples.length}`);
+            this.logger.debug(`[normalizeGraphs] updateTypes: ${parsed.updates.map((op) => op.updateType).join(', ')}`);
+            if (simpleOps && deleteTriples.length + insertTriples.length > 0) {
+                const termToString = (term) => {
+                    if (term.termType === 'NamedNode') {
+                        return `<${term.value}>`;
+                    }
+                    if (term.termType === 'Literal') {
+                        // Escape special characters in literal values
+                        const hasQuotes = term.value.includes('"');
+                        const hasNewlines = term.value.includes('\n') || term.value.includes('\r');
+                        let escaped;
+                        let useTripleQuotes = false;
+                        if (hasQuotes || hasNewlines) {
+                            // Use triple-quoted strings for values with quotes or newlines
+                            useTripleQuotes = true;
+                            escaped = term.value;
+                            // Escape triple-quote sequences
+                            escaped = escaped.replace(/"""/g, '"\\"\\""');
+                            // Escape trailing quotes to avoid """content"""" sequences
+                            if (escaped.endsWith('"')) {
+                                const match = escaped.match(/"*$/);
+                                const trailingQuotes = match ? match[0].length : 0;
+                                if (trailingQuotes > 0) {
+                                    escaped = escaped.slice(0, -trailingQuotes) + '\\"'.repeat(trailingQuotes);
+                                }
+                            }
+                        }
+                        else {
+                            // Regular escaping for simple strings
+                            escaped = term.value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+                        }
+                        const quote = useTripleQuotes ? '"""' : '"';
+                        // Handle language tags and datatypes
+                        if (term.language) {
+                            return `${quote}${escaped}${quote}@${term.language}`;
+                        }
+                        if (term.datatype && term.datatype.value !== 'http://www.w3.org/2001/XMLSchema#string') {
+                            return `${quote}${escaped}${quote}^^<${term.datatype.value}>`;
+                        }
+                        return `${quote}${escaped}${quote}`;
+                    }
+                    if (term.termType === 'BlankNode') {
+                        return `_:${term.value}`;
+                    }
+                    // Fallback for unknown term types
+                    return `<${term.value}>`;
+                };
+                const toTripleStr = (triples) => triples.map((t) => `${termToString(t.subject)} ${termToString(t.predicate)} ${termToString(t.object)} .`).join(' ');
+                let parts = [];
+                if (deleteTriples.length > 0) {
+                    parts.push(`DELETE DATA { GRAPH <${graph.value}> { ${toTripleStr(deleteTriples)} } }`);
+                }
+                if (insertTriples.length > 0) {
+                    parts.push(`INSERT DATA { GRAPH <${graph.value}> { ${toTripleStr(insertTriples)} } }`);
+                }
+                const normalizedSimple = parts.join(';\n');
+                this.logger.verbose(`Normalized SPARQL UPDATE for ${identifier.path}: ${normalizedSimple}`);
+                return normalizedSimple;
+            }
+            parsed.updates = parsed.updates.map((op) => {
+                switch (op.updateType) {
+                    case 'deleteinsert':
+                    case 'insertdelete':
+                        return {
+                            ...op,
+                            delete: toGraphQuads(op.delete),
+                            insert: toGraphQuads(op.insert),
+                            where: op.where && op.where.length > 0 ? [{ type: 'graph', name: graph, patterns: op.where.map(rewritePattern) }] : [],
+                        };
+                    case 'delete':
+                    case 'insert': {
+                        const deleteQuads = toGraphQuads(op.delete) ?? [];
+                        const insertQuads = toGraphQuads(op.insert) ?? [];
+                        return {
+                            updateType: 'insertdelete',
+                            delete: deleteQuads,
+                            insert: insertQuads,
+                            where: op.where && op.where.length > 0 ? [{ type: 'graph', name: graph, patterns: op.where.map(rewritePattern) }] : [],
+                        };
+                    }
+                    default:
+                        return op;
+                }
+            });
+            const normalized = this.generator.stringify(parsed);
+            this.logger.verbose(`Normalized SPARQL UPDATE for ${identifier.path}: ${normalized}`);
+            return normalized;
+        }
+        catch (error) {
+            console.log(`[normalizeGraphs] Parse FAILED for ${identifier.path}: ${error}`);
+            console.log(`[normalizeGraphs] Input was: ${updateText.slice(0, 300)}`);
+            const fallbackResult = wrapDefaultGraph(updateText);
+            console.log(`[normalizeGraphs] Fallback result: ${fallbackResult.slice(0, 300)}`);
+            return fallbackResult;
+        }
+    }
+    isSparqlUpdatePatch(patch) {
+        return typeof patch.algebra === 'object';
+    }
+    isSparqlCapable(accessor) {
+        return typeof accessor === 'object' &&
+            accessor !== null &&
+            typeof accessor.executeSparqlUpdate === 'function' &&
+            typeof accessor.getMetadata === 'function';
+    }
+    async setRepresentation(identifier, representation, conditions) {
+        return super.setRepresentation(identifier, representation, conditions);
+    }
+}
+exports.SparqlUpdateResourceStore = SparqlUpdateResourceStore;
+//# sourceMappingURL=SparqlUpdateResourceStore.js.map