Fix

Author: rkodev

packages/abstractions/src/apiClientBuilder.ts

@@ -9,53 +9,58 @@ import { BackingStoreParseNodeFactory, BackingStoreSerializationWriterProxyFacto
 
 /**
  * Registers the default serializer to the registry.
+ * @param serializationWriterFactoryRegistry The registry to which the default serializer will be registered.
  * @param type the class of the factory to be registered.
  */
-export function registerDefaultSerializer(type: new () => SerializationWriterFactory): void {
+export function registerDefaultSerializer(serializationWriterFactoryRegistry: SerializationWriterFactoryRegistry, type: new () => SerializationWriterFactory): void {
 	if (!type) throw new Error("Type is required");
 	const serializer = new type();
-	SerializationWriterFactoryRegistry.defaultInstance.contentTypeAssociatedFactories.set(serializer.getValidContentType(), serializer);
+	serializationWriterFactoryRegistry.contentTypeAssociatedFactories.set(serializer.getValidContentType(), serializer);
 }
 /**
  * Registers the default deserializer to the registry.
+ * @param parseNodeFactoryRegistry The registry to which the default deserializer will be registered.
  * @param type the class of the factory to be registered.
  */
-export function registerDefaultDeserializer(type: new () => ParseNodeFactory): void {
+export function registerDefaultDeserializer(parseNodeFactoryRegistry: ParseNodeFactoryRegistry, type: new () => ParseNodeFactory): void {
 	if (!type) throw new Error("Type is required");
 	const deserializer = new type();
-	ParseNodeFactoryRegistry.defaultInstance.contentTypeAssociatedFactories.set(deserializer.getValidContentType(), deserializer);
+	parseNodeFactoryRegistry.contentTypeAssociatedFactories.set(deserializer.getValidContentType(), deserializer);
 }
 /**
  * Enables the backing store on default serialization writers and the given serialization writer.
+ * @param serializationWriterFactoryRegistry The serialization writer factory registry to enable the backing store on.
+ * @param parseNodeFactoryRegistry The parse node factory registry to enable the backing store on.
  * @param original The serialization writer to enable the backing store on.
  * @returns A new serialization writer with the backing store enabled.
  */
-export function enableBackingStoreForSerializationWriterFactory(original: SerializationWriterFactory): SerializationWriterFactory {
+export function enableBackingStoreForSerializationWriterFactory(serializationWriterFactoryRegistry: SerializationWriterFactoryRegistry, parseNodeFactoryRegistry: ParseNodeFactoryRegistry, original: SerializationWriterFactory): SerializationWriterFactory {
 	if (!original) throw new Error("Original must be specified");
 	let result = original;
 	if (original instanceof SerializationWriterFactoryRegistry) {
 		enableBackingStoreForSerializationRegistry(original);
 	} else {
 		result = new BackingStoreSerializationWriterProxyFactory(original);
 	}
-	enableBackingStoreForSerializationRegistry(SerializationWriterFactoryRegistry.defaultInstance);
-	enableBackingStoreForParseNodeRegistry(ParseNodeFactoryRegistry.defaultInstance);
+	enableBackingStoreForSerializationRegistry(serializationWriterFactoryRegistry);
+	enableBackingStoreForParseNodeRegistry(parseNodeFactoryRegistry);
 	return result;
 }
 /**
  * Enables the backing store on default parse node factories and the given parse node factory.
+ * @param parseNodeFactoryRegistry The parse node factory registry to enable the backing store on.
  * @param original The parse node factory to enable the backing store on.
  * @returns A new parse node factory with the backing store enabled.
  */
-export function enableBackingStoreForParseNodeFactory(original: ParseNodeFactory): ParseNodeFactory {
+export function enableBackingStoreForParseNodeFactory(parseNodeFactoryRegistry: ParseNodeFactoryRegistry, original: ParseNodeFactory): ParseNodeFactory {
 	if (!original) throw new Error("Original must be specified");
 	let result = original;
 	if (original instanceof ParseNodeFactoryRegistry) {
 		enableBackingStoreForParseNodeRegistry(original);
 	} else {
 		result = new BackingStoreParseNodeFactory(original);
 	}
-	enableBackingStoreForParseNodeRegistry(ParseNodeFactoryRegistry.defaultInstance);
+	enableBackingStoreForParseNodeRegistry(parseNodeFactoryRegistry);
 	return result;
 }
 /**

packages/abstractions/src/requestAdapter.ts

@@ -18,6 +18,12 @@ export interface RequestAdapter {
 	 * @returns the serialization writer factory currently in use for the HTTP core service.
 	 */
 	getSerializationWriterFactory(): SerializationWriterFactory;
+
+	/**
+	 * Gets the parse node factory currently in use for the HTTP core service.
+	 * @returns the parse node factory currently in use for the HTTP core service.
+	 */
+	getParseNodeFactory(): ParseNodeFactory;
 	/**
 	 * Executes the HTTP request specified by the given RequestInformation and returns the deserialized response model.
 	 * @param requestInfo the request info to execute.

packages/abstractions/src/serialization/kiotaJsonSerializer.ts

@@ -8,64 +8,72 @@ import { deserialize, deserializeCollection, serialize, serializeCollection, ser
 import type { Parsable } from "./parsable";
 import type { ParsableFactory } from "./parsableFactory";
 import type { ModelSerializerFunction } from "./serializationFunctionTypes";
+import { SerializationWriterFactoryRegistry } from "./serializationWriterFactoryRegistry";
+import { ParseNodeFactoryRegistry } from "./parseNodeFactoryRegistry";
 
 const jsonContentType = "application/json";
 /**
  * Serializes a parsable object into a buffer
+ * @param serializationWriterFactoryRegistry the serialization writer factory registry
  * @param value the value to serialize
  * @param serializationFunction the serialization function for the model type
  * @returns a buffer containing the serialized value
  */
-export function serializeToJson<T extends Parsable>(value: T, serializationFunction: ModelSerializerFunction<T>): ArrayBuffer {
-	return serialize(jsonContentType, value, serializationFunction);
+export function serializeToJson<T extends Parsable>(serializationWriterFactoryRegistry: SerializationWriterFactoryRegistry, value: T, serializationFunction: ModelSerializerFunction<T>): ArrayBuffer {
+	return serialize(serializationWriterFactoryRegistry, jsonContentType, value, serializationFunction);
 }
 
 /**
  * Serializes a parsable object into a string representation
+ * @param serializationWriterFactoryRegistry the serialization writer factory registry
  * @param value the value to serialize
  * @param serializationFunction the serialization function for the model type
  * @returns a string representing the serialized value
  */
-export function serializeToJsonAsString<T extends Parsable>(value: T, serializationFunction: ModelSerializerFunction<T>): string {
-	return serializeAsString(jsonContentType, value, serializationFunction);
+export function serializeToJsonAsString<T extends Parsable>(serializationWriterFactoryRegistry: SerializationWriterFactoryRegistry, value: T, serializationFunction: ModelSerializerFunction<T>): string {
+	return serializeAsString(serializationWriterFactoryRegistry, jsonContentType, value, serializationFunction);
 }
 
 /**
  * Serializes a collection of parsable objects into a buffer
+ * @param serializationWriterFactoryRegistry the serialization writer factory registry
  * @param values the value to serialize
  * @param serializationFunction the serialization function for the model type
  * @returns a string representing the serialized value
  */
-export function serializeCollectionToJson<T extends Parsable>(values: T[], serializationFunction: ModelSerializerFunction<T>): ArrayBuffer {
-	return serializeCollection(jsonContentType, values, serializationFunction);
+export function serializeCollectionToJson<T extends Parsable>(serializationWriterFactoryRegistry: SerializationWriterFactoryRegistry, values: T[], serializationFunction: ModelSerializerFunction<T>): ArrayBuffer {
+	return serializeCollection(serializationWriterFactoryRegistry, jsonContentType, values, serializationFunction);
 }
 
 /**
  * Serializes a collection of parsable objects into a string representation
+ * @param serializationWriterFactoryRegistry the serialization writer factory registry
  * @param values the value to serialize
  * @param serializationFunction the serialization function for the model type
  * @returns a string representing the serialized value
  */
-export function serializeCollectionToJsonAsString<T extends Parsable>(values: T[], serializationFunction: ModelSerializerFunction<T>): string {
-	return serializeCollectionAsString(jsonContentType, values, serializationFunction);
+export function serializeCollectionToJsonAsString<T extends Parsable>(serializationWriterFactoryRegistry: SerializationWriterFactoryRegistry, values: T[], serializationFunction: ModelSerializerFunction<T>): string {
+	return serializeCollectionAsString(serializationWriterFactoryRegistry, jsonContentType, values, serializationFunction);
 }
 
 /**
  * Deserializes a buffer into a parsable object
+ * @param parseNodeFactoryRegistry the parse node factory registry
  * @param bufferOrString the value to serialize
  * @param factory the factory for the model type
  * @returns the deserialized parsable object
  */
-export function deserializeFromJson<T extends Parsable>(bufferOrString: ArrayBuffer | string, factory: ParsableFactory<T>): Parsable {
-	return deserialize(jsonContentType, bufferOrString, factory);
+export function deserializeFromJson<T extends Parsable>(parseNodeFactoryRegistry: ParseNodeFactoryRegistry, bufferOrString: ArrayBuffer | string, factory: ParsableFactory<T>): Parsable {
+	return deserialize(parseNodeFactoryRegistry, jsonContentType, bufferOrString, factory);
 }
 
 /**
- * Deserializes a buffer into a a collection of parsable object
+ * Deserializes a buffer into a collection of parsable object
+ * @param parseNodeFactoryRegistry the parse node factory registry
  * @param bufferOrString the value to serialize
  * @param factory the factory for the model type
  * @returns the deserialized collection of parsable objects
  */
-export function deserializeCollectionFromJson<T extends Parsable>(bufferOrString: ArrayBuffer | string, factory: ParsableFactory<T>): T[] | undefined {
-	return deserializeCollection(jsonContentType, bufferOrString, factory);
+export function deserializeCollectionFromJson<T extends Parsable>(parseNodeFactoryRegistry: ParseNodeFactoryRegistry, bufferOrString: ArrayBuffer | string, factory: ParsableFactory<T>): T[] | undefined {
+	return deserializeCollection(parseNodeFactoryRegistry, jsonContentType, bufferOrString, factory);
 }

packages/abstractions/src/serialization/kiotaSerializer.ts

@@ -14,60 +14,65 @@ import { SerializationWriterFactoryRegistry } from "./serializationWriterFactory
 
 /**
  * Serializes a parsable object into a buffer
+ * @param serializationWriterFactoryRegistry the serialization writer factory registry
  * @param contentType the content type to serialize to
  * @param value the value to serialize
  * @param serializationFunction the serialization function for the model type
  * @returns a buffer containing the serialized value
  */
-export function serialize<T extends Parsable>(contentType: string, value: T, serializationFunction: ModelSerializerFunction<T>): ArrayBuffer {
-	const writer = getSerializationWriter(contentType, value, serializationFunction);
+export function serialize<T extends Parsable>(serializationWriterFactoryRegistry: SerializationWriterFactoryRegistry, contentType: string, value: T, serializationFunction: ModelSerializerFunction<T>): ArrayBuffer {
+	const writer = getSerializationWriter(serializationWriterFactoryRegistry, contentType, value, serializationFunction);
 	writer.writeObjectValue(undefined, value, serializationFunction);
 	return writer.getSerializedContent();
 }
 /**
  * Serializes a parsable object into a string representation
+ * @param serializationWriterFactoryRegistry the serialization writer factory registry
  * @param contentType the content type to serialize to
  * @param value the value to serialize
  * @param serializationFunction the serialization function for the model type
  * @returns a string representing the serialized value
  */
-export function serializeToString<T extends Parsable>(contentType: string, value: T, serializationFunction: ModelSerializerFunction<T>): string {
-	const buffer = serialize(contentType, value, serializationFunction);
+export function serializeToString<T extends Parsable>(serializationWriterFactoryRegistry: SerializationWriterFactoryRegistry, contentType: string, value: T, serializationFunction: ModelSerializerFunction<T>): string {
+	const buffer = serialize(serializationWriterFactoryRegistry, contentType, value, serializationFunction);
 	return getStringValueFromBuffer(buffer);
 }
 /**
  * Serializes a collection of parsable objects into a buffer
+ * @param serializationWriterFactoryRegistry the serialization writer factory registry
  * @param contentType the content type to serialize to
  * @param values the value to serialize
  * @param serializationFunction the serialization function for the model type
  * @returns a string representing the serialized value
  */
-export function serializeCollection<T extends Parsable>(contentType: string, values: T[], serializationFunction: ModelSerializerFunction<T>): ArrayBuffer {
-	const writer = getSerializationWriter(contentType, values, serializationFunction);
+export function serializeCollection<T extends Parsable>(serializationWriterFactoryRegistry: SerializationWriterFactoryRegistry, contentType: string, values: T[], serializationFunction: ModelSerializerFunction<T>): ArrayBuffer {
+	const writer = getSerializationWriter(serializationWriterFactoryRegistry, contentType, values, serializationFunction);
 	writer.writeCollectionOfObjectValues(undefined, values, serializationFunction);
 	return writer.getSerializedContent();
 }
 
 /**
  * Serializes a collection of parsable objects into a string representation
+ * @param serializationWriterFactoryRegistry the serialization writer factory registry
  * @param contentType the content type to serialize to
  * @param values the value to serialize
  * @param serializationFunction the serialization function for the model type
  * @returns a string representing the serialized value
  */
-export function serializeCollectionToString<T extends Parsable>(contentType: string, values: T[], serializationFunction: ModelSerializerFunction<T>): string {
-	const buffer = serializeCollection(contentType, values, serializationFunction);
+export function serializeCollectionToString<T extends Parsable>(serializationWriterFactoryRegistry: SerializationWriterFactoryRegistry, contentType: string, values: T[], serializationFunction: ModelSerializerFunction<T>): string {
+	const buffer = serializeCollection(serializationWriterFactoryRegistry, contentType, values, serializationFunction);
 	return getStringValueFromBuffer(buffer);
 }
 
 /**
  * Gets a serialization writer for a given content type
+ * @param serializationWriterFactoryRegistry the serialization writer factory registry
  * @param contentType the content type to serialize to
  * @param value the value to serialize
  * @param serializationFunction the serialization function for the model type
  * @returns the serialization writer for the given content type
  */
-function getSerializationWriter(contentType: string, value: unknown, serializationFunction: unknown): SerializationWriter {
+function getSerializationWriter(serializationWriterFactoryRegistry: SerializationWriterFactoryRegistry, contentType: string, value: unknown, serializationFunction: unknown): SerializationWriter {
 	if (!contentType) {
 		throw new Error("content type cannot be undefined or empty");
 	}
@@ -77,7 +82,7 @@ function getSerializationWriter(contentType: string, value: unknown, serializati
 	if (!serializationFunction) {
 		throw new Error("serializationFunction cannot be undefined");
 	}
-	return SerializationWriterFactoryRegistry.defaultInstance.getSerializationWriter(contentType);
+	return serializationWriterFactoryRegistry.getSerializationWriter(contentType);
 }
 
 /**
@@ -92,26 +97,28 @@ function getStringValueFromBuffer(buffer: ArrayBuffer): string {
 
 /**
  * Deserializes a buffer into a parsable object
+ * @param parseNodeFactoryRegistry the parse node factory registry
  * @param contentType the content type to serialize to
  * @param bufferOrString the value to serialize
  * @param factory the factory for the model type
  * @returns the deserialized parsable object
  */
-export function deserialize<T extends Parsable>(contentType: string, bufferOrString: ArrayBuffer | string, factory: ParsableFactory<T>): Parsable {
+export function deserialize<T extends Parsable>(parseNodeFactoryRegistry: ParseNodeFactoryRegistry, contentType: string, bufferOrString: ArrayBuffer | string, factory: ParsableFactory<T>): Parsable {
 	if (typeof bufferOrString === "string") {
 		bufferOrString = getBufferFromString(bufferOrString);
 	}
-	const reader = getParseNode(contentType, bufferOrString, factory);
+	const reader = getParseNode(parseNodeFactoryRegistry, contentType, bufferOrString, factory);
 	return reader.getObjectValue(factory);
 }
 /**
  * Deserializes a buffer into a parsable object
+ * @param parseNodeFactoryRegistry the parse node factory registry
  * @param contentType the content type to serialize to
  * @param buffer the value to deserialize
  * @param factory the factory for the model type
  * @returns the deserialized parsable object
  */
-function getParseNode(contentType: string, buffer: ArrayBuffer, factory: unknown): ParseNode {
+function getParseNode(parseNodeFactoryRegistry: ParseNodeFactoryRegistry, contentType: string, buffer: ArrayBuffer, factory: unknown): ParseNode {
 	if (!contentType) {
 		throw new Error("content type cannot be undefined or empty");
 	}
@@ -121,20 +128,21 @@ function getParseNode(contentType: string, buffer: ArrayBuffer, factory: unknown
 	if (!factory) {
 		throw new Error("factory cannot be undefined");
 	}
-	return ParseNodeFactoryRegistry.defaultInstance.getRootParseNode(contentType, buffer);
+	return parseNodeFactoryRegistry.getRootParseNode(contentType, buffer);
 }
 /**
- * Deserializes a buffer into a a collection of parsable object
+ * Deserializes a buffer into a collection of parsable object
+ * @param parseNodeFactoryRegistry the parse node factory registry
  * @param contentType the content type to serialize to
  * @param bufferOrString the value to serialize
  * @param factory the factory for the model type
  * @returns the deserialized collection of parsable objects
  */
-export function deserializeCollection<T extends Parsable>(contentType: string, bufferOrString: ArrayBuffer | string, factory: ParsableFactory<T>): T[] | undefined {
+export function deserializeCollection<T extends Parsable>(parseNodeFactoryRegistry: ParseNodeFactoryRegistry, contentType: string, bufferOrString: ArrayBuffer | string, factory: ParsableFactory<T>): T[] | undefined {
 	if (typeof bufferOrString === "string") {
 		bufferOrString = getBufferFromString(bufferOrString);
 	}
-	const reader = getParseNode(contentType, bufferOrString, factory);
+	const reader = getParseNode(parseNodeFactoryRegistry, contentType, bufferOrString, factory);
 	return reader.getCollectionOfObjectValues(factory);
 }
 

packages/abstractions/src/serialization/parseNodeFactoryRegistry.ts

@@ -11,8 +11,6 @@ import type { ParseNodeFactory } from "./parseNodeFactory";
  * This factory holds a list of all the registered factories for the various types of nodes.
  */
 export class ParseNodeFactoryRegistry implements ParseNodeFactory {
-	/** Default singleton instance of the registry to be used when registring new factories that should be available by default. */
-	public static readonly defaultInstance = new ParseNodeFactoryRegistry();
 	public getValidContentType(): string {
 		throw new Error("The registry supports multiple content types. Get the registered factory instead.");
 	}