Merge pull request #367 from microsoftgraph/feat/auth-middleware-factory

feat: add authorization middleware support and factory overload

Author: baywet

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
     ".": "1.0.0-preview.14"
-}
+}

src/adapter/BaseGraphRequestAdapter.ts

@@ -7,7 +7,7 @@ import {
 } from "@microsoft/kiota-abstractions";
 import { HttpClient, type ObservabilityOptions, ObservabilityOptionsImpl } from "@microsoft/kiota-http-fetchlibrary";
 import { DefaultRequestAdapter } from "@microsoft/kiota-bundle";
-import { GraphHttpClient } from "../http/GraphHttpClient.js";
+import { createGraphClientFactory } from "../http/GraphClientFactory.js";
 
 /**
  * Base request adapter for graph clients. Bootstraps telemetry and other aspects.
@@ -29,7 +29,7 @@ export class BaseGraphRequestAdapter extends DefaultRequestAdapter {
     authenticationProvider: AuthenticationProvider,
     parseNodeFactory: ParseNodeFactory = ParseNodeFactoryRegistry.defaultInstance,
     serializationWriterFactory: SerializationWriterFactory = SerializationWriterFactoryRegistry.defaultInstance,
-    httpClient: HttpClient = new GraphHttpClient({
+    httpClient: HttpClient = createGraphClientFactory({
       graphServiceTargetVersion,
       graphServiceLibraryClientVersion,
     }),

src/http/GraphClientFactory.ts

@@ -0,0 +1,51 @@
+import { BaseBearerTokenAuthenticationProvider } from "@microsoft/kiota-abstractions";
+import { Middleware } from "@microsoft/kiota-http-fetchlibrary";
+import { GraphHttpClient } from "./GraphHttpClient.js";
+import { getDefaultMiddlewares, GraphTelemetryOption } from "../middleware";
+
+/**
+ * Creates an instance of `GraphHttpClient`, with the provided middlewares and custom fetch implementation both parameters are optional.
+ * if no middlewares are provided, the default middlewares will be used.
+ * @param {GraphTelemetryOption} graphTelemetryOption - The telemetry options for the Graph client.
+ * @param {(request: string, init: RequestInit) => Promise<Response>} customFetch - The custom fetch function to use for HTTP requests.
+ * @param {BaseBearerTokenAuthenticationProvider} [authenticationProvider] - Optional authentication provider for bearer token.
+ * @param {Middleware[]} [middlewares] - Optional array of middleware to use in the HTTP pipeline.
+ * @returns {GraphHttpClient} - A new instance of `GraphHttpClient`.
+ * @example
+ * ```Typescript
+ * // Example usage of createGraphClientFactory method with graphTelemetryOption , customFetch and middlewares parameters provided
+ *  createGraphClientFactory(graphTelemetryOption, customFetch, [middleware1, middleware2]);
+ * ```
+ * @example
+ * ```Typescript
+ * // Example usage of createGraphClientFactory method with only graphTelemetryOption and customFetch parameter provided
+ * createGraphClientFactory(graphTelemetryOption, customFetch);
+ * ```
+ * @example
+ * ```Typescript
+ * // Example usage of createGraphClientFactory method with only graphTelemetryOption and middlewares parameter provided
+ * createGraphClientFactory(graphTelemetryOption, undefined, [middleware1, middleware2]);
+ * ```
+ * @example
+ * ```Typescript
+ * // Example usage of createGraphClientFactory method with only graphTelemetryOption parameter provided
+ * createGraphClientFactory(graphTelemetryOption);
+ * ```
+ */
+export const createGraphClientFactory = (
+  graphTelemetryOption: GraphTelemetryOption,
+  customFetch?: (request: string, init: RequestInit) => Promise<Response>,
+  authenticationProvider?: BaseBearerTokenAuthenticationProvider,
+  middlewares?: Middleware[],
+): GraphHttpClient => {
+  const middleware =
+    middlewares ||
+    getDefaultMiddlewares(
+      {
+        customFetch,
+        graphTelemetryOption,
+      },
+      authenticationProvider,
+    );
+  return new GraphHttpClient(graphTelemetryOption, customFetch, ...middleware);
+};

src/http/index.ts

@@ -1 +1,2 @@
+export * from "./GraphClientFactory.js";
 export * from "./GraphHttpClient.js";

src/middleware/MiddlewareFactory.ts

@@ -3,13 +3,21 @@ import {
   MiddlewareFactory,
   UrlReplaceHandler,
   UrlReplaceHandlerOptions,
+  AuthorizationHandler,
 } from "@microsoft/kiota-http-fetchlibrary";
 import { GraphTelemetryOption } from "./GraphTelemetryOption.js";
 import { GraphTelemetryHandler } from "./GraphTelemetryHandler.js";
 import { defaultUrlReplacementPairs } from "../utils/Constants.js";
+import { BaseBearerTokenAuthenticationProvider } from "@microsoft/kiota-abstractions";
 
-export const getDefaultMiddlewares = (options: MiddlewareFactoryOptions = { customFetch: fetch }): Middleware[] => {
+export const getDefaultMiddlewares = (
+  options: MiddlewareFactoryOptions = { customFetch: fetch },
+  authenticationProvider?: BaseBearerTokenAuthenticationProvider | null,
+): Middleware[] => {
   let kiotaChain = MiddlewareFactory.getDefaultMiddlewares(options?.customFetch);
+  if (authenticationProvider) {
+    kiotaChain.unshift(new AuthorizationHandler(authenticationProvider));
+  }
   const additionalMiddleware: Middleware[] = [
     new UrlReplaceHandler(
       new UrlReplaceHandlerOptions({

test/http/GraphHttpClient.ts

@@ -0,0 +1,48 @@
+import { assert, describe, it } from "vitest";
+import { GraphHttpClient, GraphTelemetryOption } from "../../src";
+import { BaseBearerTokenAuthenticationProvider } from "@microsoft/kiota-abstractions";
+import type { Middleware } from "@microsoft/kiota-http-fetchlibrary";
+import { createGraphClientFactory } from "../../src/http/GraphClientFactory";
+
+const graphTelemetryOption: GraphTelemetryOption = {};
+
+/**
+ * Counts the number of middlewares in a linked list of middlewares.
+ *
+ * @param {Middleware} middleware - The starting middleware.
+ * @returns {number} The count of middlewares.
+ */
+const countMiddlewares = (middleware: Middleware): number => {
+  let count = 0;
+  while (middleware.next) {
+    count++;
+    middleware = middleware.next;
+  }
+  return count;
+};
+
+describe("GraphHttpClient tests", () => {
+  describe("Constructor", () => {
+    it("Should create instance of graph http client", () => {
+      const client = new GraphHttpClient(graphTelemetryOption);
+      assert.isNotNull(client, "Client is null");
+    });
+
+    it("Should create instance of graph http client with middleware", () => {
+      const middleware = {} as Middleware;
+      const client = new GraphHttpClient(graphTelemetryOption, undefined, middleware);
+      assert.isNotNull(client, "Client is null");
+    });
+
+    it("Should add auth middleware when provider is given", () => {
+      const client = new GraphHttpClient(graphTelemetryOption);
+      const count = countMiddlewares((client as any)["middleware"] as Middleware);
+      assert.equal(8, count);
+
+      const authenticationProvider = new BaseBearerTokenAuthenticationProvider({} as any);
+      const clientWithProvider = createGraphClientFactory(graphTelemetryOption, undefined, authenticationProvider);
+      const count2 = countMiddlewares((clientWithProvider as any)["middleware"] as Middleware);
+      assert.equal(9, count2);
+    });
+  });
+});