using fetch definitions only when required

http/typescript/fetch/package.json

@@ -44,22 +44,22 @@
         "test:es": " npm run build:es && mocha 'dist/es/test/common/**/*.js'  --require  esm && mocha 'dist/es/test/node/**/*.js'  --require  esm"
     },
     "dependencies": {
-        "@microsoft/kiota-abstractions": "file:microsoft-kiota-abstractions-1.0.21.tgz",
+        "@microsoft/kiota-abstractions": "1.0.31",
         "node-fetch": "^2.6.5",
         "tslib": "2.3.1"
     },
     "devDependencies": {
+        "@microsoft/kiota-abstractions": "^1.0.30",
         "@rollup/plugin-commonjs": "^21.0.0",
         "@rollup/plugin-node-resolve": "^13.0.5",
         "@types/chai": "^4.2.22",
+        "@types/mocha": "^9.0.0",
         "@types/node": "^17.0.13",
         "@types/sinon": "^10.0.4",
-        "chai": "^4.3.4",
-        "@microsoft/kiota-abstractions": "^1.0.30",
-        "cross-fetch": "^3.1.5",
-        "typescript": "^4.6.2",
         "@typescript-eslint/eslint-plugin": "^5.14.0",
         "@typescript-eslint/parser": "^5.14.0",
+        "chai": "^4.3.4",
+        "cross-fetch": "^3.1.5",
         "eslint": "^8.11.0",
         "eslint-config-prettier": "^8.5.0",
         "eslint-plugin-prettier": "^4.0.0",
@@ -72,13 +72,14 @@
         "karma-mocha": "^2.0.1",
         "karma-typescript": "^5.5.2",
         "mocha": "^8.4.0",
-        "prettier": "^1.19.1",
+        "prettier": "^2.5.1",
         "rollup": "^2.58.0",
         "rollup-plugin-terser": "^7.0.2",
         "sinon": "^11.1.2",
-        "tslib": "^2.3.1"
+        "tslib": "^2.3.1",
+        "typescript": "^4.6.2"
     },
     "publishConfig": {
         "registry": "https://npm.pkg.github.com"
     }
-}
+}

http/typescript/fetch/src/browser/index.ts

@@ -11,10 +11,11 @@
 export * from "../fetchRequestAdapter";
 export * from "../httpClient";
 export * from "../middlewares/middleware";
-export * from "../middlewares/browser/defaultFetchHandler";
 export * from "../middlewares/customFetchHandler";
 export * from "../middlewares/retryHandler";
 export * from "../middlewares/options/retryHandlerOptions";
-export * from "../middlewares/middlewareContext";
 export * from "../middlewares/browser/middlewareFactory";
+
+export * from "../middlewares/telemetryHandler";
+
 export * from "../utils/headersUtil";

http/typescript/fetch/src/fetchRequestAdapter.ts

@@ -172,7 +172,7 @@ export class FetchRequestAdapter implements RequestAdapter {
 		await this.authenticationProvider.authenticateRequest(requestInfo);
 
 		const request = this.getRequestFromRequestInformation(requestInfo);
-		return await this.httpClient.executeFetch(requestInfo.URL, request);
+		return await this.httpClient.executeFetch(requestInfo.URL, request, requestInfo.getRequestOptions());
 	};
 	private setBaseUrlForRequestInformation = (requestInfo: RequestInformation): void => {
 		requestInfo.pathParameters["baseurl"] = this.baseUrl;

http/typescript/fetch/src/httpClient.ts

@@ -1,8 +1,8 @@
+import { type RequestOption } from "@microsoft/kiota-abstractions";
+
 import { CustomFetchHandler } from "./middlewares/customFetchHandler";
-import { DefaultFetchHandler } from "./middlewares/defaultFetchHandler";
 import { Middleware } from "./middlewares/middleware";
 import { MiddlewareFactory } from "./middlewares/middlewareFactory";
-import { FetchRequestInfo, FetchRequestInit, FetchResponse } from "./utils/fetchDefinitions";
 
 export class HttpClient {
 	private middleware: Middleware;
@@ -14,29 +14,22 @@ export class HttpClient {
 	 * If middlewares param is undefined, the httpClient instance will use the default array of middlewares.
 	 * Set middlewares to `null` if you do not wish to use middlewares.
 	 * If custom fetch is undefined, the httpClient instance uses the `DefaultFetchHandler`
-	 * @param {(request: FetchRequestInfo, init?: FetchRequestInit) => Promise < FetchResponse >} custom fetch function - a Fetch API implementation
+	 * @param {(request: string, init?: RequestInit) => Promise < Response >} custom fetch function - a Fetch API implementation
 	 *
 	 */
-	public constructor(private customFetch?: (request: FetchRequestInfo, init?: FetchRequestInit) => Promise<FetchResponse>, ...middlewares: Middleware[]) {
+	public constructor(private customFetch?: (request: string, init?: RequestInit) => Promise<Response>, ...middlewares: Middleware[]) {
 		// Use default middleware chain if middlewares and custom fetch function are  undefined
-		if (!middlewares.length) {
+		if (!middlewares.length || middlewares[0] === null) {
 			if (this.customFetch) {
 				this.setMiddleware(...MiddlewareFactory.getDefaultMiddlewareChain(customFetch));
 			} else {
 				this.setMiddleware(...MiddlewareFactory.getDefaultMiddlewareChain());
 			}
 		} else {
-			if (middlewares[0] === null) {
-				if (!customFetch) {
-					this.setMiddleware(...MiddlewareFactory.getDefaultMiddlewareChain());
-				}
-				return;
+			if (this.customFetch) {
+				this.setMiddleware(...middlewares, new CustomFetchHandler(customFetch));
 			} else {
-				if (this.customFetch) {
-					this.setMiddleware(...middlewares, new CustomFetchHandler(customFetch));
-				} else {
-					this.setMiddleware(...middlewares);
-				}
+				this.setMiddleware(...middlewares);
 			}
 		}
 	}
@@ -79,7 +72,7 @@ export class HttpClient {
 	 * @param options request options.
 	 * @returns the promise resolving the response.
 	 */
-	public async executeFetch(url: string, requestInit?: FetchRequestInit, requestOptions?: RequestOption[]): Promise<FetchResponse> {
+	public async executeFetch(url: string, requestInit?: RequestInit, requestOptions?: Record<string, RequestOption>): Promise<Response> {
 		if (this.customFetch && !this.middleware) {
 			return this.customFetch(url, requestInit);
 		}

http/typescript/fetch/src/index.ts

@@ -10,13 +10,14 @@
 export * from "./fetchRequestAdapter";
 export * from "./httpClient";
 export * from "./middlewares/middleware";
-export * from "./middlewares/defaultFetchHandler";
 export * from "./middlewares/customFetchHandler";
 export * from "./middlewares/redirectHandler";
 export * from "./middlewares/retryHandler";
 export * from "./middlewares/options/redirectHandlerOptions";
 export * from "./middlewares/options/retryHandlerOptions";
-export * from "./middlewares/middlewareContext";
+export * from "./middlewares/options/telemetryHandlerOptions";
+export * from "./middlewares/telemetryHandler";
+
 export * from "./middlewares/middlewareFactory";
 export * from "./utils/headersUtil";
 export * from "./utils/fetchDefinitions";

http/typescript/fetch/src/middlewares/browser/middlewareFactory.ts

@@ -9,12 +9,10 @@
  * @module MiddlewareFactory
  */
 
-import { FetchRequestInfo, FetchRequestInit, FetchResponse } from "../../utils/fetchDefinitions";
 import { CustomFetchHandler } from "../customFetchHandler";
 import { Middleware } from "../middleware";
 import { RetryHandlerOptions } from "../options/retryHandlerOptions";
 import { RetryHandler } from "../retryHandler";
-import { DefaultFetchHandler } from "./defaultFetchHandler";
 
 /**
  * @class
@@ -28,7 +26,7 @@ export class MiddlewareFactory {
 	 * @param {AuthenticationProvider} authProvider - The authentication provider instance
 	 * @returns an array of the middleware handlers of the default middleware chain
 	 */
-	public static getDefaultMiddlewareChain(customFetch?: (request: FetchRequestInfo, init?: FetchRequestInit) => Promise<FetchResponse>): Middleware[] {
+	public static getDefaultMiddlewareChain(customFetch?: (request: string, init?: RequestInit) => Promise<Response>): Middleware[] {
 		// Browsers handles redirection automatically and do not require the redirectionHandler
 
 		const middlewareArray: Middleware[] = [];
@@ -37,7 +35,7 @@ export class MiddlewareFactory {
 		if (customFetch) {
 			middlewareArray.push(new CustomFetchHandler(customFetch));
 		} else {
-			middlewareArray.push(new CustomFetchHandler(fetch as any));
+			middlewareArray.push(new CustomFetchHandler(fetch));
 		}
 		return middlewareArray;
 	}

http/typescript/fetch/src/middlewares/customFetchHandler.ts

@@ -9,7 +9,6 @@
  * @module FetchHandler
  */
 
-import { FetchRequestInfo, FetchRequestInit, FetchResponse } from "../utils/fetchDefinitions";
 import { Middleware } from "./middleware";
 
 /**
@@ -25,7 +24,7 @@ export class CustomFetchHandler implements Middleware {
 	 */
 	next: Middleware;
 
-	constructor(private customFetch?: (input: FetchRequestInfo, init: FetchRequestInit) => Promise<FetchResponse>) {}
+	constructor(private customFetch?: (input: string, init: RequestInit) => Promise<Response>) {}
 
 	/**
 	 * @public
@@ -34,7 +33,7 @@ export class CustomFetchHandler implements Middleware {
 	 * @param {Context} context - The request context object
 	 * @returns A promise that resolves to nothing
 	 */
-	public async execute(url: string, requestInit: FetchRequestInit): Promise<FetchResponse> {
+	public async execute(url: string, requestInit: RequestInit): Promise<Response> {
 		return await this.customFetch(url, requestInit);
 	}
 }

http/typescript/fetch/src/middlewares/middleware.ts

@@ -4,8 +4,7 @@
  * See License in the project root for license information.
  * -------------------------------------------------------------------------------------------
  */
-import {RequestOption} from "@microsoft/kiota-abstractions"
-import { FetchRequestInit, FetchResponse } from "../utils/fetchDefinitions";
+import {RequestOption} from "@microsoft/kiota-abstractions";
 // use import types
 /** Defines the contract for a middleware in the request execution pipeline. */
 export interface Middleware {
@@ -18,5 +17,5 @@ export interface Middleware {
 	 * @param url The URL of the request.
 	 * @return A promise that resolves to the response object.
 	 */
-	execute(url: string, requestInit: FetchRequestInit, requestOptions?: Record<string, RequestOption>): Promise<FetchResponse>;
+	execute(url: string, requestInit: RequestInit, requestOptions?: Record<string, RequestOption>): Promise<Response>;
 }

http/typescript/fetch/src/middlewares/middlewareFactory.ts

@@ -8,9 +8,8 @@
 /**
  * @module MiddlewareFactory
  */
+import fetch from "node-fetch";
 
- import fetch from "node-fetch";
-import { FetchRequestInfo, FetchRequestInit, FetchResponse } from "../utils/fetchDefinitions";
 import { CustomFetchHandler } from "./customFetchHandler";
 import { Middleware } from "./middleware";
 import { RedirectHandlerOptions } from "./options/redirectHandlerOptions";
@@ -30,7 +29,7 @@ export class MiddlewareFactory {
 	 * @param {AuthenticationProvider} authProvider - The authentication provider instance
 	 * @returns an array of the middleware handlers of the default middleware chain
 	 */
-	public static getDefaultMiddlewareChain(customFetch?: (request: FetchRequestInfo, init?: FetchRequestInit) => Promise<FetchResponse>): Middleware[] {
+	public static getDefaultMiddlewareChain(customFetch?: (request: string, init?: RequestInit) => Promise<Response>): Middleware[] {
 		const middlewareArray: Middleware[] = [];
 		const retryHandler = new RetryHandler(new RetryHandlerOptions());
 		middlewareArray.push(retryHandler);

http/typescript/fetch/src/middlewares/options/RetryHandlerOptions.ts

@@ -11,13 +11,13 @@
 
 import { RequestOption } from "@microsoft/kiota-abstractions";
 
-import { FetchRequestInit, FetchResponse } from "../../utils/fetchDefinitions";
+import { FetchResponse } from "../../utils/fetchDefinitions";
 
 /**
  * @type
  * A type declaration for shouldRetry callback
  */
-export type ShouldRetry = (delay: number, attempt: number, request: string, options: FetchRequestInit | undefined, response: FetchResponse) => boolean;
+export type ShouldRetry = (delay: number, attempt: number, request: string, options: RequestInit | undefined, response: FetchResponse) => boolean;
 
 export const RetryHandlerOptionKey = "RetryHandlerOptionKey";
 

http/typescript/fetch/src/middlewares/options/telemetryHandlerOptions.ts

@@ -0,0 +1,6 @@
+import { RequestOption } from "@microsoft/kiota-abstractions";
+
+export interface TelemetryHandlerOptions extends RequestOption {
+	telemetryConfigurator: (url: string, requestInit: RequestInit, requestOptions?: Record<string, RequestOption>, telemetryInfomation?: unknown) => void;
+	telemetryInfomation: unknown;
+}

http/typescript/fetch/src/middlewares/redirectHandler.ts

@@ -9,11 +9,10 @@
  * @module RedirectHandler
  */
 
-import { HttpMethod } from "@microsoft/kiota-abstractions";
+import { type RequestOption, HttpMethod } from "@microsoft/kiota-abstractions";
 
 import { FetchRequestInit, FetchResponse } from "../utils/fetchDefinitions";
 import { Middleware } from "./middleware";
-import { MiddlewareContext } from "./middlewareContext";
 import { RedirectHandlerOptionKey, RedirectHandlerOptions } from "./options/redirectHandlerOptions";
 
 /**
@@ -139,17 +138,6 @@ export class RedirectHandler implements Middleware {
         return typeof requestAuthority !== "undefined" && typeof redirectAuthority !== "undefined" && requestAuthority !== redirectAuthority;
     }
 
-    /**
-     * @private
-     * @async
-     * To update a request url with the redirect url
-     * @param {string} redirectUrl - The redirect url value
-     * @param {Context} context - The context object value
-     * @returns Nothing
-     */
-    private updateRequestUrl(redirectUrl: string, context: MiddlewareContext) {
-        context.requestUrl = redirectUrl;
-    }
 
     /**
      * @private
@@ -161,7 +149,7 @@ export class RedirectHandler implements Middleware {
      * @returns A promise that resolves to nothing
      */
     private async executeWithRedirect(url: string, fetchRequestInit: FetchRequestInit, redirectCount: number, requestOptions?: Record<string, RequestOption>): Promise<FetchResponse> {
-        const response = await this.next.execute(url, fetchRequestInit, requestOptions);
+        const response = await this.next.execute(url, fetchRequestInit as RequestInit, requestOptions);
         if (redirectCount < this.options.maxRedirects && this.isRedirect(response) && this.hasLocationHeader(response) && this.options.shouldRedirect(response)) {
             ++redirectCount;
             if (response.status === RedirectHandler.STATUS_CODE_SEE_OTHER) {
@@ -187,13 +175,13 @@ export class RedirectHandler implements Middleware {
      * @param {Context} context - The context object of the request
      * @returns A Promise that resolves to nothing
      */
-    public execute(url: string, requestInit: FetchRequestInit, requestOptions?: Record<string, RequestOption>): Promise<FetchResponse> {
+    public execute(url: string, requestInit: RequestInit, requestOptions?: Record<string, RequestOption>): Promise<FetchResponse> {
         const redirectCount = 0;
-        if (requestOptions && requestOptions[RedirectHandlerOptionKey]))
+        if (requestOptions && requestOptions[RedirectHandlerOptionKey])
         {
             this.options = requestOptions[RedirectHandlerOptionKey] as RedirectHandlerOptions;
         }
-        requestInit.redirect = RedirectHandler.MANUAL_REDIRECT;
-        return this.executeWithRedirect(url, requestInit, redirectCount, requestOptions);
+        (requestInit as FetchRequestInit).redirect = RedirectHandler.MANUAL_REDIRECT;
+        return this.executeWithRedirect(url, requestInit as FetchRequestInit, redirectCount, requestOptions);
     }
 }