adding MiddlewareControl

abstractions/typescript/src/authentication/baseBearerTokenAuthenticationProvider.ts

@@ -14,7 +14,7 @@ export abstract class BaseBearerTokenAuthenticationProvider implements Authentic
                 throw new Error('Could not get an authorization token');
             }
             if(!request.headers) {
-                request.headers = new Map<string, string>();
+                //request.headers = new Map<string, string>();
             }
             request.headers?.set(BaseBearerTokenAuthenticationProvider.authorizationHeaderKey, `Bearer ${token}`);
         }

abstractions/typescript/src/index.ts

@@ -9,5 +9,4 @@ export * from "./nativeResponseWrapper";
 export * from './serialization';
 export * from './utils';
 export * from './store';
-export * from './middlewareOption';
-export * from './FetchInitOptions';
+export * from './middlewareOption';

abstractions/typescript/src/requestInformation.ts

@@ -3,13 +3,11 @@ import { ReadableStream } from 'web-streams-polyfill/es2018';
 import { Parsable } from "./serialization";
 import { HttpCore } from "./httpCore";
 import { MiddlewareOption } from "./middlewareOption";
-import { RequestDetails } from "./requestDetails";
-import { FetchOptions } from "./FetchInitOptions";
 
 /** This class represents an abstract HTTP request. */
-export class RequestInformation implements RequestDetails{
+export class RequestInformation{
     /** The URI of the request. */
-    public URI?: RequestInfo;
+    public URI?: string;
     /**
      * Sets the URI of the request.
      * @param currentPath the current path (scheme, host, port, path, query parameters) of the request.
@@ -45,9 +43,8 @@ export class RequestInformation implements RequestDetails{
     public queryParameters: Map<string, string | number | boolean | undefined> = new Map<string, string | number | boolean | undefined>(); //TODO: case insensitive
     /** The Request Headers. */
     public headers: Headers = new Headers(); //TODO: case insensitive
-
-
-    public options?: FetchOptions;
+
+    public options?: Map<string,unknown>;
 
     private _middlewareOptions = new Map<string, MiddlewareOption>(); //TODO: case insensitive
     /** Gets the middleware options for the request. */

http/typescript/fetch/package.json

@@ -32,6 +32,7 @@
     "@microsoft/kiota-abstractions": "file:../../../abstractions/typescript",
     "@types/node-fetch": "^3.0.3",
     "cross-fetch": "^3.1.4",
+    "tslib": "^2.3.1",
     "web-streams-polyfill": "^3.1.1"
   },
   "devDependencies": {

http/typescript/fetch/src/httpClient.ts

@@ -1,11 +1,11 @@
 import { Middleware } from "./middlewares/middleware";
-import { MiddlewareContext } from "./middlewareContext";
+import { MiddlewareContext } from "./middlewares/middlewareContext";
 import { FetchHandler } from "./middlewares/fetchHandler";
 import { MiddlewareFactory } from "./middlewares/middlewareFactory";
 
 /** Default fetch client with options and a middleware pipleline for requests execution. */
 export class HttpClient {
-    private middleware: Middleware
+    private middleware: Middleware;
     /**
      * Instantiates a new HttpClient.
      * @param middlewares middlewares to be used for requests execution.

http/typescript/fetch/src/httpCore.ts

@@ -1,9 +1,11 @@
 import { AuthenticationProvider, BackingStoreFactory, BackingStoreFactorySingleton, HttpCore as IHttpCore, Parsable, ParseNodeFactory, RequestInformation, ResponseHandler, ParseNodeFactoryRegistry, enableBackingStoreForParseNodeFactory, SerializationWriterFactoryRegistry, enableBackingStoreForSerializationWriterFactory, SerializationWriterFactory } from '@microsoft/kiota-abstractions';
-import { ReadableStream } from 'web-streams-polyfill';
+import { ReadableStream } from 'web-streams-polyfill/es2018';
 import { URLSearchParams } from 'url';
 import { HttpClient } from './httpClient';
+import  {Headers as crossHeaders} from "cross-fetch"
+
+import { MiddlewareContext } from './middlewares/middlewareContext';
 
-import { MiddlewareContext } from './middlewareContext';
 export class HttpCore implements IHttpCore {
     public getSerializationWriterFactory(): SerializationWriterFactory {
         return this.serializationWriterFactory;
@@ -16,86 +18,83 @@ export class HttpCore implements IHttpCore {
      * @param httpClient the http client to use to execute requests.
      */
     public constructor(public readonly authenticationProvider: AuthenticationProvider, private parseNodeFactory: ParseNodeFactory = ParseNodeFactoryRegistry.defaultInstance, private serializationWriterFactory: SerializationWriterFactory = SerializationWriterFactoryRegistry.defaultInstance, private readonly httpClient: HttpClient = new HttpClient()) {
-        if(!authenticationProvider) {
+        if (!authenticationProvider) {
             throw new Error('authentication provider cannot be null');
         }
-        if(!parseNodeFactory) {
+        if (!parseNodeFactory) {
             throw new Error('parse node factory cannot be null');
         }
-        if(!serializationWriterFactory) {
+        if (!serializationWriterFactory) {
             throw new Error('serialization writer factory cannot be null');
         }
-        if(!httpClient) {
+        if (!httpClient) {
             throw new Error('http client cannot be null');
         }
     }
     private getResponseContentType = (response: Response): string | undefined => {
         const header = response.headers.get("content-type")?.toLowerCase();
-        if(!header) return undefined;
+        if (!header) return undefined;
         const segments = header.split(';');
-        if(segments.length === 0) return undefined;
+        if (segments.length === 0) return undefined;
         else return segments[0];
     }
-    public sendCollectionAsync = async <ModelType extends Parsable>(requestInfo: RequestInformation, type: new() => ModelType, responseHandler: ResponseHandler | undefined): Promise<ModelType[]> => {
-        if(!requestInfo) {
+    public sendCollectionAsync = async <ModelType extends Parsable>(requestInfo: RequestInformation, type: new () => ModelType, responseHandler: ResponseHandler | undefined): Promise<ModelType[]> => {
+        if (!requestInfo) {
             throw new Error('requestInfo cannot be null');
         }
         await this.authenticationProvider.authenticateRequest(requestInfo);
-
-        const request = this.getRequestFromRequestInformation(requestInfo);
+
         const response = await this.httpClient.executeFetch(this.createContext(requestInfo));
-        if(responseHandler) {
+        if (responseHandler) {
             return await responseHandler.handleResponseAsync(response);
         } else {
             const payload = await response.arrayBuffer();
             const responseContentType = this.getResponseContentType(response);
-            if(!responseContentType)
+            if (!responseContentType)
                 throw new Error("no response content type found for deserialization");
-            
+
             const rootNode = this.parseNodeFactory.getRootParseNode(responseContentType, payload);
             const result = rootNode.getCollectionOfObjectValues(type);
             return result as unknown as ModelType[];
         }
     }
-    public sendAsync = async <ModelType extends Parsable>(requestInfo: RequestInformation, type: new() => ModelType, responseHandler: ResponseHandler | undefined): Promise<ModelType> => {
-        if(!requestInfo) {
+    public sendAsync = async <ModelType extends Parsable>(requestInfo: RequestInformation, type: new () => ModelType, responseHandler: ResponseHandler | undefined): Promise<ModelType> => {
+        if (!requestInfo) {
             throw new Error('requestInfo cannot be null');
         }
         await this.authenticationProvider.authenticateRequest(requestInfo);
-
-        const request = this.getRequestFromRequestInformation(requestInfo);
+
         const response = await this.httpClient.executeFetch(this.createContext(requestInfo));
-        if(responseHandler) {
+        if (responseHandler) {
             return await responseHandler.handleResponseAsync(response);
         } else {
             const payload = await response.arrayBuffer();
             const responseContentType = this.getResponseContentType(response);
-            if(!responseContentType)
+            if (!responseContentType)
                 throw new Error("no response content type found for deserialization");
-            
+
             const rootNode = this.parseNodeFactory.getRootParseNode(responseContentType, payload);
             const result = rootNode.getObjectValue(type);
             return result as unknown as ModelType;
         }
     }
     public sendPrimitiveAsync = async <ResponseType>(requestInfo: RequestInformation, responseType: "string" | "number" | "boolean" | "Date" | "ReadableStream", responseHandler: ResponseHandler | undefined): Promise<ResponseType> => {
-        if(!requestInfo) {
+        if (!requestInfo) {
             throw new Error('requestInfo cannot be null');
         }
         await this.authenticationProvider.authenticateRequest(requestInfo);
-
-        const request = this.getRequestFromRequestInformation(requestInfo);
+
         const response = await this.httpClient.executeFetch(this.createContext(requestInfo));
-        if(responseHandler) {
+        if (responseHandler) {
             return await responseHandler.handleResponseAsync(response);
         } else {
-            switch(responseType) {
+            switch (responseType) {
                 case "ReadableStream":
-                    const buffer =  await response.arrayBuffer();
+                    const buffer = await response.arrayBuffer();
                     let bufferPulled = false;
                     const stream = new ReadableStream({
                         pull: (controller) => {
-                            if(!bufferPulled) {
+                            if (!bufferPulled) {
                                 controller.enqueue(buffer.slice(0))
                                 bufferPulled = true;
                             }
@@ -108,15 +107,15 @@ export class HttpCore implements IHttpCore {
                 case 'Date':
                     const payload = await response.arrayBuffer();
                     const responseContentType = this.getResponseContentType(response);
-                    if(!responseContentType)
+                    if (!responseContentType)
                         throw new Error("no response content type found for deserialization");
-                    
+
                     const rootNode = this.parseNodeFactory.getRootParseNode(responseContentType, payload);
-                    if(responseType === 'string') {
+                    if (responseType === 'string') {
                         return rootNode.getStringValue() as unknown as ResponseType;
                     } else if (responseType === 'number') {
                         return rootNode.getNumberValue() as unknown as ResponseType;
-                    } else if(responseType === 'boolean') {
+                    } else if (responseType === 'boolean') {
                         return rootNode.getBooleanValue() as unknown as ResponseType;
                     } else if (responseType === 'Date') {
                         return rootNode.getDateValue() as unknown as ResponseType;
@@ -127,38 +126,44 @@ export class HttpCore implements IHttpCore {
         }
     }
     public sendNoResponseContentAsync = async (requestInfo: RequestInformation, responseHandler: ResponseHandler | undefined): Promise<void> => {
-        if(!requestInfo) {
+        if (!requestInfo) {
             throw new Error('requestInfo cannot be null');
         }
         await this.authenticationProvider.authenticateRequest(requestInfo);
-
-        const request = this.getRequestFromRequestInformation(requestInfo);
         const response = await this.httpClient.executeFetch(this.createContext(requestInfo));
-        if(responseHandler) {
+        if (responseHandler) {
             return await responseHandler.handleResponseAsync(response);
         }
     }
     public enableBackingStore = (backingStoreFactory?: BackingStoreFactory | undefined): void => {
         this.parseNodeFactory = enableBackingStoreForParseNodeFactory(this.parseNodeFactory);
         this.serializationWriterFactory = enableBackingStoreForSerializationWriterFactory(this.serializationWriterFactory);
-        if(!this.serializationWriterFactory || !this.parseNodeFactory)
+        if (!this.serializationWriterFactory || !this.parseNodeFactory)
             throw new Error("unable to enable backing store");
-        if(backingStoreFactory) {
+        if (backingStoreFactory) {
             BackingStoreFactorySingleton.instance = backingStoreFactory;
         }
     }
     private getRequestFromRequestInformation = (requestInfo: RequestInformation): RequestInit => {
-        const request :RequestInit = {
+        const request = {
             method: requestInfo.httpMethod?.toString(),
-            headers: new Headers(),
+            headers: new crossHeaders(),
             body: requestInfo.content,
-        }
+        } as RequestInit;
+
         requestInfo.headers?.forEach((v, k) => (request.headers as Headers).set(k, v));
+
+        requestInfo.options?.forEach((v, k) => {
+            if (k in request) {
+                request[k] = v;
+            }
+        }
+        );
         return request;
     }
-    private getRequestUrl = (requestInfo: RequestInformation) : string => {
+    private getRequestUrl (requestInfo: RequestInformation): string {
         let url = requestInfo.URI ?? '';
-        if(requestInfo.queryParameters?.size ?? -1 > 0) {
+        if (requestInfo.queryParameters?.size ?? -1 > 0) {
             const queryParametersBuilder = new URLSearchParams();
             requestInfo.queryParameters?.forEach((v, k) => {
                 queryParametersBuilder.append(k, `${v}`);
@@ -168,14 +173,15 @@ export class HttpCore implements IHttpCore {
         return url;
     }
 
-    private createContext (requestInformation : RequestInformation): MiddlewareContext{
+    private createContext(requestInformation: RequestInformation): MiddlewareContext {
 
-        const context:MiddlewareContext = {
-            request: this.getRequestUrl(requestInformation),
-            options: requestInformation.headers,
-            middlewareOptions: requestInformation.getMiddlewareOptions()
+        const url =  this.getRequestUrl(requestInformation);
+        const context: MiddlewareContext = {
+            request: url,
+            options: this.getRequestFromRequestInformation(requestInformation),
+            //middlewareControl //set from middleware options
         }
         return context;
-    }
 
-}
+    }
+}