@comake/skl-js-engine 1.3.13 → 1.3.15

package/src/SklEngine.ts

@@ -81,6 +81,8 @@ export type CapabilityInterface = Record<string, CapabilityHandler>;
 
 export type MappingResponseOption<T extends boolean> = T extends true ? JSONObject : NodeObject;
 
+export type WriteOptions = { bypassHooks?: boolean };
+
 export class SKLEngine implements SKLEngineInterface {
   private readonly queryAdapter: QueryAdapter;
   private readonly functions?: Record<string, (args: any | any[]) => any>;
@@ -149,7 +151,8 @@ export class SKLEngine implements SKLEngineInterface {
       const context = {
         entities: [],
         operation: 'find',
-        operationParameters: { options }
+        operationParameters: { options },
+        sklEngine: this
       };
 
       await globalHooks.execute(HookTypes.READ, HookStages.BEFORE, context);
@@ -176,7 +179,8 @@ export class SKLEngine implements SKLEngineInterface {
       const context = {
         entities: [],
         operation: 'findBy',
-        operationParameters: { where }
+        operationParameters: { where },
+        sklEngine: this
       };
       await globalHooks.execute(HookTypes.READ, HookStages.BEFORE, context);
       try {
@@ -208,7 +212,8 @@ export class SKLEngine implements SKLEngineInterface {
       const context = {
         entities: [],
         operation: 'findAll',
-        operationParameters: { options }
+        operationParameters: { options },
+        sklEngine: this
       };
       await globalHooks.execute(HookTypes.READ, HookStages.BEFORE, context);
       try {
@@ -228,7 +233,8 @@ export class SKLEngine implements SKLEngineInterface {
       const context = {
         entities: [],
         operation: 'groupBy',
-        operationParameters: { options }
+        operationParameters: { options },
+        sklEngine: this
       };
       await globalHooks.execute(HookTypes.READ, HookStages.BEFORE, context);
       try {
@@ -248,7 +254,8 @@ export class SKLEngine implements SKLEngineInterface {
       const context = {
         entities: [],
         operation: 'findAllBy',
-        operationParameters: { where }
+        operationParameters: { where },
+        sklEngine: this
       };
       await globalHooks.execute(HookTypes.READ, HookStages.BEFORE, context);
       try {
@@ -271,30 +278,30 @@ export class SKLEngine implements SKLEngineInterface {
     return PerformanceLogger.withSpanRoot('SklEngine.count', async() => this.queryAdapter.count(options), { options });
   }
 
-  public async save(entity: Entity): Promise<Entity>;
-  public async save(entities: Entity[]): Promise<Entity[]>;
-  public async save(entityOrEntities: Entity | Entity[]): Promise<Entity | Entity[]> {
+  public async save(entity: Entity, options?: WriteOptions): Promise<Entity>;
+  public async save(entities: Entity[], options?: WriteOptions): Promise<Entity[]>;
+  public async save(entityOrEntities: Entity | Entity[], options?: WriteOptions): Promise<Entity | Entity[]> {
     return PerformanceLogger.withSpanRoot('SklEngine.save', async() => {
       const entityArray = Array.isArray(entityOrEntities) ? entityOrEntities : [entityOrEntities];
       const isSingleEntity = !Array.isArray(entityOrEntities);
 
-      await globalHooks.executeBeforeCreate(entityArray);
+      await globalHooks.executeBeforeCreate(entityArray, { sklEngine: this, bypassHooks: options?.bypassHooks });
 
       try {
         await this.validateEntitiesConformToObjectSchema(entityArray);
         const savedEntities = await this.queryAdapter.save(entityArray);
-        await globalHooks.executeAfterCreate(savedEntities);
+        await globalHooks.executeAfterCreate(savedEntities, { sklEngine: this, bypassHooks: options?.bypassHooks });
         return isSingleEntity ? savedEntities[0] : savedEntities;
       } catch (error) {
-        await globalHooks.executeErrorCreate(entityArray, error as Error);
+        await globalHooks.executeErrorCreate(entityArray, error as Error, { sklEngine: this, bypassHooks: options?.bypassHooks });
         throw error;
       }
     }, { entityCount: Array.isArray(entityOrEntities) ? entityOrEntities.length : 1 });
   }
 
-  public async update(id: string, attributes: Partial<Entity>): Promise<void>;
-  public async update(ids: string[], attributes: Partial<Entity>): Promise<void>;
-  public async update(idOrIds: string | string[], attributes: Partial<Entity>): Promise<void> {
+  public async update(id: string, attributes: Partial<Entity>, options?: WriteOptions): Promise<void>;
+  public async update(ids: string[], attributes: Partial<Entity>, options?: WriteOptions): Promise<void>;
+  public async update(idOrIds: string | string[], attributes: Partial<Entity>, options?: WriteOptions): Promise<void> {
     return PerformanceLogger.withSpanRoot('SklEngine.update', async() => {
       const idArray = Array.isArray(idOrIds) ? idOrIds : [idOrIds];
       const isSingleEntity = !Array.isArray(idOrIds);
@@ -302,7 +309,9 @@ export class SKLEngine implements SKLEngineInterface {
       await globalHooks.execute(HookTypes.UPDATE, HookStages.BEFORE, {
         entities: [],
         operation: 'update',
-        operationParameters: { idArray, attributes }
+        operationParameters: { idArray, attributes },
+        sklEngine: this,
+        bypassHooks: options?.bypassHooks
       });
 
       try {
@@ -316,13 +325,17 @@ export class SKLEngine implements SKLEngineInterface {
         await globalHooks.execute(HookTypes.UPDATE, HookStages.AFTER, {
           entities: [],
           operation: 'update',
-          operationParameters: { idArray, attributes }
+          operationParameters: { idArray, attributes },
+          sklEngine: this,
+          bypassHooks: options?.bypassHooks
         });
       } catch (error: unknown) {
         await globalHooks.execute(HookTypes.UPDATE, HookStages.ERROR, {
           entities: [],
           operation: 'update',
-          operationParameters: { idArray, attributes }
+          operationParameters: { idArray, attributes },
+          sklEngine: this,
+          bypassHooks: options?.bypassHooks
         }, error);
         throw error;
       }
@@ -470,16 +483,18 @@ export class SKLEngine implements SKLEngineInterface {
     }
   }
 
-  public async delete(id: string): Promise<void>;
-  public async delete(ids: string[]): Promise<void>;
-  public async delete(idOrIds: string | string[]): Promise<void> {
+  public async delete(id: string, options?: WriteOptions): Promise<void>;
+  public async delete(ids: string[], options?: WriteOptions): Promise<void>;
+  public async delete(idOrIds: string | string[], options?: WriteOptions): Promise<void> {
     return PerformanceLogger.withSpanRoot('SklEngine.delete', async() => {
       const idArray = Array.isArray(idOrIds) ? idOrIds : [idOrIds];
 
       await globalHooks.execute(HookTypes.DELETE, HookStages.BEFORE, {
         entities: [],
         operation: 'delete',
-        operationParameters: { idArray }
+        operationParameters: { idArray },
+        sklEngine: this,
+        bypassHooks: options?.bypassHooks
       });
 
       try {
@@ -488,13 +503,17 @@ export class SKLEngine implements SKLEngineInterface {
         await globalHooks.execute(HookTypes.DELETE, HookStages.AFTER, {
           entities: [],
           operation: 'delete',
-          operationParameters: { idArray }
+          operationParameters: { idArray },
+          sklEngine: this,
+          bypassHooks: options?.bypassHooks
         });
       } catch (error) {
         await globalHooks.execute(HookTypes.DELETE, HookStages.ERROR, {
           entities: [],
           operation: 'delete',
-          operationParameters: { idArray }
+          operationParameters: { idArray },
+          sklEngine: this,
+          bypassHooks: options?.bypassHooks
         }, error);
         throw error;
       }
@@ -609,7 +628,7 @@ export class SKLEngine implements SKLEngineInterface {
       // Execute capability mapping before hook if appropriate -
       //  works for any mapping that can be used as a verb mapping
       if (mapping) {
-        await globalHooks.executeBeforeExecuteCapabilityMapping([capabilityArgs] as Entity[], mapping);
+        await globalHooks.executeBeforeExecuteCapabilityMapping([capabilityArgs] as Entity[], mapping, { sklEngine: this });
       }
 
       const verbReturnValue = await this.executeMapping(mapping, capabilityArgs, capabilityConfig, account);
@@ -620,7 +639,7 @@ export class SKLEngine implements SKLEngineInterface {
 
       // Execute capability mapping after hook if appropriate
       if (mapping) {
-        await globalHooks.executeAfterExecuteCapabilityMapping([capabilityArgs] as Entity[], mapping, verbReturnValue);
+        await globalHooks.executeAfterExecuteCapabilityMapping([capabilityArgs] as Entity[], mapping, verbReturnValue, { sklEngine: this });
       }
 
       this.globalCallbacks?.onCapabilityEnd?.(capability[PROP_ENTITY_ID], verbReturnValue);
@@ -632,7 +651,7 @@ export class SKLEngine implements SKLEngineInterface {
     } catch (error) {
       // Execute capability mapping error hook if appropriate
       if (mapping) {
-        await globalHooks.executeErrorExecuteCapabilityMapping([capabilityArgs] as Entity[], mapping, error as Error);
+        await globalHooks.executeErrorExecuteCapabilityMapping([capabilityArgs] as Entity[], mapping, error as Error, { sklEngine: this });
       }
       throw error;
     }

package/src/hooks/globalHooks.ts

@@ -100,6 +100,10 @@ class GlobalHooksRegistry {
    * Execute hooks for a specific operation and stage
    */
   async execute(type: symbol, stage: symbol, context: SklHookContext, resultOrError?: any): Promise<any> {
+    // Allow bypassing hooks to prevent re-entrancy from within hooks
+    if (context?.bypassHooks) {
+      return resultOrError;
+    }
     const hooksList = this.hooks.get(type)?.get(stage);
 
     if (!hooksList || hooksList.length === 0) {
@@ -166,43 +170,53 @@ class GlobalHooksRegistry {
   }
 
   // Execution convenience methods
-  async executeBeforeCreate(entities: Entity[]): Promise<void> {
-    await this.execute(HookTypes.CREATE, HookStages.BEFORE, { entities, operation: 'save', operationParameters: {}});
+  async executeBeforeCreate(entities: Entity[], extras?: Partial<SklHookContext>): Promise<void> {
+    await this.execute(
+      HookTypes.CREATE,
+      HookStages.BEFORE,
+      { entities, operation: 'save', operationParameters: {}, ...extras}
+    );
   }
 
-  async executeAfterCreate(entities: Entity | Entity[]): Promise<any> {
+  async executeAfterCreate(entities: Entity | Entity[], extras?: Partial<SklHookContext>): Promise<any> {
     if (!Array.isArray(entities)) {
       entities = [ entities ];
     }
     return this.execute(
       HookTypes.CREATE,
       HookStages.AFTER,
-      { entities, operation: 'save', operationParameters: {}},
+      { entities, operation: 'save', operationParameters: {}, ...extras},
       entities
     );
   }
 
-  async executeErrorCreate(entities: Entity[], error: Error): Promise<void> {
+  async executeErrorCreate(entities: Entity[], error: Error, extras?: Partial<SklHookContext>): Promise<void> {
     await this.execute(
       HookTypes.CREATE,
       HookStages.ERROR,
-      { entities, operation: 'save', operationParameters: {}},
+      { entities, operation: 'save', operationParameters: {}, ...extras},
       error
     );
   }
 
-  async executeBeforeExecuteCapabilityMapping(entities: Entity[], capabilityMapping: CapabilityMapping): Promise<void> {
+  async executeBeforeExecuteCapabilityMapping(
+    entities: Entity[],
+    capabilityMapping: CapabilityMapping,
+    extras?: Partial<SklHookContext>
+  ): Promise<void> {
     await this.execute(HookTypes.EXECUTE_CAPABILITY_MAPPING, HookStages.BEFORE, {
       entities,
       operation: 'executeCapabilityMapping',
-      operationParameters: { capabilityMapping }
+      operationParameters: { capabilityMapping },
+      ...extras
     });
   }
 
   async executeAfterExecuteCapabilityMapping(
     entities: Entity[],
     capabilityMapping: CapabilityMapping,
-    result: any
+    result: any,
+    extras?: Partial<SklHookContext>
   ): Promise<any> {
     return this.execute(
       HookTypes.EXECUTE_CAPABILITY_MAPPING,
@@ -210,7 +224,8 @@ class GlobalHooksRegistry {
       {
         entities,
         operation: 'executeCapabilityMapping',
-        operationParameters: { capabilityMapping }
+        operationParameters: { capabilityMapping },
+        ...extras
       },
       result
     );
@@ -219,7 +234,8 @@ class GlobalHooksRegistry {
   async executeErrorExecuteCapabilityMapping(
     entities: Entity[],
     capabilityMapping: CapabilityMapping,
-    error: Error
+    error: Error,
+    extras?: Partial<SklHookContext>
   ): Promise<void> {
     await this.execute(
       HookTypes.EXECUTE_CAPABILITY_MAPPING,
@@ -227,7 +243,8 @@ class GlobalHooksRegistry {
       {
         entities,
         operation: 'executeCapabilityMapping',
-        operationParameters: { capabilityMapping }
+        operationParameters: { capabilityMapping },
+        ...extras
       },
       error
     );

package/src/hooks/types.ts

@@ -1,7 +1,9 @@
-import type { Entity } from '../util/Types';
+import type { Entity, SKLEngineInterface } from '../util/Types';
 
 export type SklHookContext = {
   entities: Entity[];
   operation: string;
   operationParameters: Record<string, any>;
+  sklEngine?: SKLEngineInterface;
+  bypassHooks?: boolean;
 };

package/src/storage/query-adapter/sparql/SparqlUpdateBuilder.ts

@@ -43,6 +43,7 @@ export interface EntityUpdateQueries {
 export interface EntityUpdateTriples {
   entityTriples: Triple[];
   timestampTriples: Triple[];
+  insertions: GraphQuads[];
 }
 
 export interface SparqlUpdateBuilderArgs {
@@ -106,9 +107,9 @@ export class SparqlUpdateBuilder {
     return ids.flatMap((id): InsertDeleteOperation[] => {
       const subject = DataFactory.namedNode(id);
       const { attributesToUpdate, attributesToDelete } = this.partitionAttributes(attributes);
-      const deletionTriples = this.partialEntityToDeletionTriples(attributesToUpdate, subject);
-      const insertionTriples = this.partialEntityToTriples(subject, attributesToUpdate);
-      const deleteOnlyTriples = this.partialEntityToDeletionTriples(attributesToDelete, subject);
+      const { triples: deletionTriples, deletions: deletionDeletions } = this.partialEntityToDeletionTriples(attributesToUpdate, subject);
+      const { triples: insertionTriples, insertions: insertionInsertions } = this.partialEntityToTriples(subject, attributesToUpdate);
+      const { triples: deleteOnlyTriples } = this.partialEntityToDeletionTriples(attributesToDelete, subject);
 
       const updates: InsertDeleteOperation[] = [];
 
@@ -126,10 +127,26 @@ export class SparqlUpdateBuilder {
         } as InsertDeleteOperation);
       }
 
+      for (const deletion of deletionDeletions) {
+        updates.push({
+          updateType: 'insertdelete',
+          delete: [ deletion ],
+          insert: [],
+          where: [
+            ...deletion.triples.map(
+              (triple): Pattern => createSparqlOptional([ createSparqlBasicGraphPattern([ triple ]) ])
+            )
+          ],
+          using: {
+            default: [ deletion.name ]
+          }
+        } as InsertDeleteOperation);
+      }
+
       if (insertionTriples.length > 0) {
         updates.push({
           updateType: 'insert',
-          insert: [ createSparqlGraphQuads(subject, insertionTriples) ]
+          insert: [ createSparqlGraphQuads(subject, insertionTriples), ...insertionInsertions ]
         } as InsertDeleteOperation);
       }
 
@@ -192,9 +209,9 @@ export class SparqlUpdateBuilder {
     return entities.reduce(
       (obj: EntityUpdateQueries, entity): EntityUpdateQueries => {
         const entityGraphName = DataFactory.namedNode(entity['@id']);
-        const { entityTriples, timestampTriples } = this.entityToTriples(entity, entityGraphName);
+        const { entityTriples, timestampTriples, insertions } = this.entityToTriples(entity, entityGraphName);
         obj.clear.push(createSparqlClearUpdate(entityGraphName));
-        obj.insertions.push(createSparqlGraphQuads(entityGraphName, entityTriples));
+        obj.insertions.push(createSparqlGraphQuads(entityGraphName, entityTriples), ...insertions);
         if (timestampTriples.length > 0) {
           obj.timestampInsertions.push(createSparqlGraphQuads(entityGraphName, timestampTriples));
         }
@@ -218,45 +235,52 @@ export class SparqlUpdateBuilder {
     });
   }
 
-  private partialEntityToDeletionTriples(entity: NodeObject, subject: NamedNode): Triple[] {
-    return Object.keys(entity).reduce((triples: Triple[], key): Triple[] => {
+  private partialEntityToDeletionTriples(entity: NodeObject, subject: NamedNode): { triples: Triple[]; deletions: GraphQuads[] } {
+    return Object.entries(entity).reduce((acc: { triples: Triple[]; deletions: GraphQuads[] }, [ key, value ]): { triples: Triple[]; deletions: GraphQuads[] } => {
       if (key !== '@id') {
-        return [
-          ...triples,
-          this.buildTriplesWithSubjectPredicateAndVariableValue(
-            subject,
-            DataFactory.namedNode(key),
-            this.variableGenerator.getNext()
-          )
-        ];
+        let deletions: GraphQuads[] = [];
+        if (value && typeof value === 'object' && '@id' in value && typeof value['@id'] === 'string' && '@type' in value) {
+          const { triples: nestedTriples, deletions: nestedDeletions } = this.partialEntityToDeletionTriples(value as NodeObject, DataFactory.namedNode(value['@id']));
+          deletions = [ ...deletions, createSparqlGraphQuads(DataFactory.namedNode(value['@id']), nestedTriples), ...nestedDeletions ];
+        }
+        return {
+          triples: [
+            ...acc.triples,
+            this.buildTriplesWithSubjectPredicateAndVariableValue(
+              subject,
+              key === '@type' ? rdfTypeNamedNode : DataFactory.namedNode(key),
+              this.variableGenerator.getNext()
+            )
+          ],
+          deletions: [ ...acc.deletions, ...deletions ]
+        };
       }
-      return triples;
-    }, []);
+      return acc;
+    }, { triples: [], deletions: [] });
   }
 
-  private partialEntityToTriples(subject: NamedNode, entity: NodeObject): Triple[] {
-    const entityTriples = Object.entries(entity).reduce((triples: Triple[], [ key, value ]): Triple[] => {
+  private partialEntityToTriples(subject: NamedNode, entity: NodeObject): { triples: Triple[]; insertions: GraphQuads[] } {
+    return Object.entries(entity).reduce((acc: { triples: Triple[]; insertions: GraphQuads[] }, [ key, value ]): { triples: Triple[]; insertions: GraphQuads[] } => {
       const values = ensureArray(value);
       if (key !== '@id') {
-        let predicateTriples: Triple[];
+        let predicateTriples: { triples: Triple[]; insertions: GraphQuads[] };
         if (key === '@type') {
-          predicateTriples = this.buildTriplesWithSubjectPredicateAndIriValue(
+          predicateTriples = { triples: this.buildTriplesWithSubjectPredicateAndIriValue(
             subject,
             rdfTypeNamedNode,
             values as string[]
-          );
+          ), insertions: [] };
         } else {
           predicateTriples = this.buildTriplesForSubjectPredicateAndValues(subject, key, values);
         }
-        return [ ...triples, ...predicateTriples ];
+        return { triples: [ ...acc.triples, ...predicateTriples.triples ], insertions: [ ...acc.insertions, ...predicateTriples.insertions ] };
       }
-      return triples;
-    }, []);
-    return entityTriples;
+      return acc;
+    }, { triples: [], insertions: [] });
   }
 
   private entityToTriples(entity: NodeObject, subject: BlankNode | NamedNode): EntityUpdateTriples {
-    const entityTriples = Object.entries(entity).reduce((triples: Triple[], [ key, value ]): Triple[] => {
+    const entityTriples = Object.entries(entity).reduce((acc: { triples: Triple[]; insertions: GraphQuads[] }, [ key, value ]): { triples: Triple[]; insertions: GraphQuads[] } => {
       const values = ensureArray(value);
       if (key !== '@id') {
         if (key === '@type') {
@@ -265,15 +289,15 @@ export class SparqlUpdateBuilder {
             rdfTypeNamedNode,
             values as string[]
           );
-          return [ ...triples, ...predicateTriples ];
+          return { triples: [ ...acc.triples, ...predicateTriples ], insertions: acc.insertions };
         }
         if (!(this.setTimestamps && key === EngineConstants.prop.dateModified)) {
           const predicateTriples = this.buildTriplesForSubjectPredicateAndValues(subject, key, values);
-          return [ ...triples, ...predicateTriples ];
+          return { triples: [ ...acc.triples, ...predicateTriples.triples ], insertions: [ ...acc.insertions, ...predicateTriples.insertions ] };
         }
       }
-      return triples;
-    }, []);
+      return acc;
+    }, { triples: [], insertions: [] });
 
     const timestampTriples = [];
     if (this.setTimestamps && subject.termType === 'NamedNode') {
@@ -283,7 +307,8 @@ export class SparqlUpdateBuilder {
       timestampTriples.push({ subject, predicate: modified, object: now });
     }
     return {
-      entityTriples,
+      entityTriples: entityTriples.triples,
+      insertions: entityTriples.insertions,
       timestampTriples
     };
   }
@@ -292,10 +317,14 @@ export class SparqlUpdateBuilder {
     subject: BlankNode | NamedNode,
     predicate: string,
     values: any[]
-  ): Triple[] {
+  ): { triples: Triple[]; insertions: GraphQuads[] } {
     const predicateTerm = DataFactory.namedNode(predicate);
-    return values.flatMap((value: any): Triple[] =>
-      this.buildTriplesWithSubjectPredicateAndValue(subject, predicateTerm, value));
+    // Return values.flatMap((value: any): { triples: Triple[]; insertions: GraphQuads[] } =>
+    //   this.buildTriplesWithSubjectPredicateAndValue(subject, predicateTerm, value));
+    return values.reduce((acc: { triples: Triple[]; insertions: GraphQuads[] }, value: any) => {
+      const { triples, insertions } = this.buildTriplesWithSubjectPredicateAndValue(subject, predicateTerm, value);
+      return { triples: [ ...acc.triples, ...triples ], insertions: [ ...acc.insertions, ...insertions ] };
+    }, { triples: [], insertions: [] });
   }
 
   private buildTriplesWithSubjectPredicateAndIriValue(
@@ -329,26 +358,33 @@ export class SparqlUpdateBuilder {
     subject: BlankNode | NamedNode,
     predicate: NamedNode,
     value: any
-  ): Triple[] {
+  ): { triples: Triple[]; insertions: GraphQuads[] } {
     const isObject = typeof value === 'object';
     if (isObject) {
       if ('@list' in value) {
-        return this.buildTriplesForList(subject, predicate, value['@list']);
+        return { triples: this.buildTriplesForList(subject, predicate, value['@list']), insertions: [] };
       }
       if ('@value' in value) {
-        return [ { subject, predicate, object: this.jsonLdValueObjectToLiteral(value) } as Triple ];
+        return { triples: [ { subject, predicate, object: this.jsonLdValueObjectToLiteral(value) } as Triple ], insertions: [] };
       }
 
       const isReferenceObject = '@id' in value;
       const isBlankNodeReferenceObject = !isReferenceObject || (value['@id'] as string).startsWith('_:');
       if (isBlankNodeReferenceObject) {
-        return this.buildTriplesForBlankNode(subject, predicate, value as NodeObject);
+        return { triples: this.buildTriplesForBlankNode(subject, predicate, value as NodeObject), insertions: [] };
       }
       if (isReferenceObject) {
-        return [ { subject, predicate, object: DataFactory.namedNode(value['@id']) } as Triple ];
+        const triples = [ 
+          { subject, predicate, object: DataFactory.namedNode(value['@id']) } as Triple
+        ];
+        if (value['@type']) {
+          const { entityTriples, insertions } = this.entityToTriples(value as NodeObject, DataFactory.namedNode(value['@id']));
+          return { triples, insertions: [ ...insertions, createSparqlGraphQuads(DataFactory.namedNode(value['@id']), entityTriples) ] };
+        }
+        return { triples, insertions: [] };
       }
     }
-    return [ { subject, predicate, object: valueToLiteral(value) } as Triple ];
+    return { triples: [ { subject, predicate, object: valueToLiteral(value) } as Triple ], insertions: [] };
   }
 
   private jsonLdValueObjectToLiteral(value: ValueObject): Term {
@@ -372,7 +408,7 @@ export class SparqlUpdateBuilder {
         : [{ subject: blankNode, predicate: restPredicate, object: nilPredicate }];
     return [
       { subject, predicate, object: blankNode },
-      ...this.buildTriplesWithSubjectPredicateAndValue(blankNode, firstPredicate, value[0]),
+      ...this.buildTriplesWithSubjectPredicateAndValue(blankNode, firstPredicate, value[0]).triples,
       ...rest
     ];
   }