auto dependabot: bump the kiota group with 2 updates

src/adapter/BaseGraphRequestAdapter.ts

@@ -27,8 +27,8 @@ export class BaseGraphRequestAdapter extends DefaultRequestAdapter {
     graphServiceTargetVersion: string,
     graphServiceLibraryClientVersion: string,
     authenticationProvider: AuthenticationProvider,
-    parseNodeFactory: ParseNodeFactory = ParseNodeFactoryRegistry.defaultInstance,
-    serializationWriterFactory: SerializationWriterFactory = SerializationWriterFactoryRegistry.defaultInstance,
+    parseNodeFactory: ParseNodeFactory = new ParseNodeFactoryRegistry(),
+    serializationWriterFactory: SerializationWriterFactory = new SerializationWriterFactoryRegistry(),
     httpClient: HttpClient = createGraphClientFactory({
       graphServiceTargetVersion,
       graphServiceLibraryClientVersion,

src/content/BatchResponseContent.ts

@@ -10,7 +10,7 @@
  */
 
 import { BatchResponseBody, BatchResponse } from "./BatchRequestStep.js";
-import { Parsable, deserializeFromJson, ParsableFactory } from "@microsoft/kiota-abstractions";
+import { Parsable, ParsableFactory, ParseNodeFactoryRegistry } from "@microsoft/kiota-abstractions";
 
 /**
  * @class
@@ -61,13 +61,18 @@ export class BatchResponseContent {
    * Retrieves a parsable response by request ID.
    * @template T - The type of the parsable response.
    * @param {string} requestId - The request ID value.
+   * @param parseNodeFactoryRegistry - The registry to create parse nodes.
    * @param {ParsableFactory<T>} factory - The factory to create the parsable response.
    * @returns {T | undefined} The parsable response object instance for the particular request, or undefined if not found.
    */
-  public getParsableResponseById<T extends Parsable>(requestId: string, factory: ParsableFactory<T>): T | undefined {
+  public getParsableResponseById<T extends Parsable>(
+    requestId: string,
+    parseNodeFactoryRegistry: ParseNodeFactoryRegistry,
+    factory: ParsableFactory<T>,
+  ): T | undefined {
     const res = this.responses.get(requestId);
     if (res?.body) {
-      const result = deserializeFromJson(res.body, factory);
+      const result = parseNodeFactoryRegistry.deserializeFromJson(res.body, factory);
       return result as T;
     }
     return undefined;

src/content/BatchResponseContentCollection.ts

@@ -11,12 +11,15 @@
 
 import { BatchResponseContent } from "./BatchResponseContent.js";
 import { BatchResponse } from "./BatchRequestStep.js";
-import { deserializeFromJson, Parsable, ParsableFactory } from "@microsoft/kiota-abstractions";
+import { Parsable, ParsableFactory, ParseNodeFactoryRegistry } from "@microsoft/kiota-abstractions";
 
 /**
  * Represents a collection of BatchResponseContent.
  */
 export class BatchResponseContentCollection {
+  /**
+   * An array of BatchResponseContent.
+   */
   public readonly batchResponseContent: BatchResponseContent[] = [];
 
   /**
@@ -54,13 +57,18 @@ export class BatchResponseContentCollection {
   /**
    * Gets the parsable response by the specified request ID.
    * @param requestId - The ID of the request.
+   * @param parseNodeFactoryRegistry - The registry to create parse nodes.
    * @param factory - The factory to create the Parsable instance.
    * @returns The parsable response, or undefined if not found.
    */
-  public getParsableResponseById<T extends Parsable>(requestId: string, factory: ParsableFactory<T>): T | undefined {
+  public getParsableResponseById<T extends Parsable>(
+    requestId: string,
+    parseNodeFactoryRegistry: ParseNodeFactoryRegistry,
+    factory: ParsableFactory<T>,
+  ): T | undefined {
     const res = this.getResponseById(requestId);
     if (res?.body) {
-      const result = deserializeFromJson(res.body, factory);
+      const result = parseNodeFactoryRegistry.deserializeFromJson(res.body, factory);
       return result as T;
     }
     return undefined;

test/content/BatchRequestContent.ts

@@ -9,9 +9,9 @@ import {
   ParseNode,
   Parsable,
   Headers,
-  registerDefaultDeserializer,
+  ParseNodeFactoryRegistry,
 } from "@microsoft/kiota-abstractions";
-import { JsonParseNodeFactory, JsonSerializationWriterFactory } from "@microsoft/kiota-serialization-json";
+import { JsonParseNodeFactory } from "@microsoft/kiota-serialization-json";
 // @ts-ignore
 import { createGraphErrorFromDiscriminatorValue } from "../tasks/PageIterator";
 import { createCipheriv } from "node:crypto";
@@ -154,14 +154,22 @@ describe("BatchRequestContent tests", () => {
       assert.equal(response?.status, 200);
     });
     it("Can parse a response a response by Id", () => {
-      registerDefaultDeserializer(JsonParseNodeFactory);
+      if (!(adapter.getParseNodeFactory() instanceof ParseNodeFactoryRegistry)) {
+        throw new Error("Invalid parse node factory");
+      }
+      const parseNodeFactoryRegistry = adapter.getParseNodeFactory() as ParseNodeFactoryRegistry;
+      parseNodeFactoryRegistry.registerDefaultDeserializer(JsonParseNodeFactory, adapter.getBackingStoreFactory());
 
       const sampleArrayBuffer = new TextEncoder().encode(JSON.stringify({ value: [1, 2, 3], id: "1", name: "test" }));
       const requestContent = new BatchResponseContent({
         responses: [{ id: "1", status: 200, headers: {}, body: sampleArrayBuffer }],
       });
 
-      const response = requestContent.getParsableResponseById<SampleResponse>("1", createSampleFromDiscriminatorValue);
+      const response = requestContent.getParsableResponseById<SampleResponse>(
+        "1",
+        parseNodeFactoryRegistry as ParseNodeFactoryRegistry,
+        createSampleFromDiscriminatorValue,
+      );
       assert.isNotNull(response);
       assert.equal(response?.value.length, 3);
       assert.equal(response?.id, "1");

test/utils/DummyRequestAdapter.ts

@@ -14,12 +14,15 @@ import {
   type ErrorMappings,
   Parsable,
   type ParsableFactory,
+  ParseNodeFactory,
   type PrimitiveTypesForDeserialization,
   type PrimitiveTypesForDeserializationType,
   RequestAdapter,
   type RequestInformation,
   SerializationWriterFactory,
   SerializationWriterFactoryRegistry,
+  InMemoryBackingStoreFactory,
+  ParseNodeFactoryRegistry,
 } from "@microsoft/kiota-abstractions";
 
 import { JsonSerializationWriterFactory } from "@microsoft/kiota-serialization-json";
@@ -35,7 +38,10 @@ export class DummyRequestAdapter implements RequestAdapter {
   requests: RequestInformation[] = [];
   serializationWriterFactory = new SerializationWriterFactoryRegistry();
 
-  constructor() {
+  constructor(
+    private parseNodeFactory: ParseNodeFactory = new ParseNodeFactoryRegistry(),
+    private backingStoreFactory = new InMemoryBackingStoreFactory(),
+  ) {
     const serializer = new JsonSerializationWriterFactory();
     this.serializationWriterFactory.contentTypeAssociatedFactories.set(serializer.getValidContentType(), serializer);
   }
@@ -128,4 +134,12 @@ export class DummyRequestAdapter implements RequestAdapter {
     this.requests.push(requestInfo);
     return Promise.resolve(this.response.shift());
   }
+
+  getBackingStoreFactory(): BackingStoreFactory {
+    return this.backingStoreFactory;
+  }
+
+  getParseNodeFactory(): ParseNodeFactory {
+    return this.parseNodeFactory;
+  }
 }