Using Microsoft Kiota in TypeScript/JavaScript

Kiota is a command-line tool used to generate code files in various programming languages from Swagger and OpenAPI specifications. Currently, it supports:

• .NET
• CLI (C# System.CommandLine)
• Go
• Java
• PHP
• Python
• TypeScript/JavaScript

Official documentation:
https://learn.microsoft.com/en-us/openapi/kiota/

Official repository:
https://github.com/microsoft/kiota

From my experience, this tool is still immature and has many bugs. It seems to have been developed internally within Azure for quickly generating SDKs in different languages, primarily for the Microsoft Graph API, and was later open-sourced.

Without further ado, let's discuss how to generate TypeScript code using this tool.

First, install Kiota, which can be done through the .NET CLI tool, a VSCode extension, and other forms. Then, the tool can generate code files. However, one important point is that the generated code files have dependencies and require the relevant Kiota libraries! Therefore, this comes with a cost! I personally find it relatively heavy and quite difficult to use!

Search for Microsoft Kiota in VSCode and install it:

Then click to open the API description document.

Follow the prompt to output the Swagger/OpenAPI document address, which supports formats like json and yaml.

After generating the code, there will be many files generated.

In the directory, there will be an xxxClient, which is the entry file, while the other files are model classes and HTTP handlers for routes with different names. Generally, controllers are used for routing, so the directory is organized according to the corresponding URL routing structure.

Next, install the following packages in your project:

npm install @microsoft/kiota-abstractions
npm install @microsoft/kiota-http-fetchlibrary
npm install @microsoft/kiota-serialization-form
npm install @microsoft/kiota-serialization-json
npm install @microsoft/kiota-serialization-text
npm install @microsoft/kiota-serialization-multipart

Import the dependencies in your code:

import { AnonymousAuthenticationProvider } from '@microsoft/kiota-abstractions';
import { FetchRequestAdapter } from '@microsoft/kiota-http-fetchlibrary';

Import the generated code files:

import { ApiClient } from '../apiclient/apiClient';

Instantiate and initialize the basic configuration for HTTP requests:

const authProvider = new AnonymousAuthenticationProvider();
const adapter = new FetchRequestAdapter(authProvider);
adapter.baseUrl = "https://aaa.com";
const myClient = new ApiClient(adapter);

Send an HTTP GET request:

var response = await myClient.控制器名称.方法名称.get();

The above code demonstrates how to call a path. You can explore the exact paths in the code directory, which generally follows a hierarchical structure. For example, /account/add, calling code:

var response = await myClient.account.add.get();

However, calling it can easily result in errors.

The parameter of type “Record<string, string[]> | undefined” cannot be assigned to the parameter of type “Headers | undefined”. 
  The type “Record<string, string[]>” is missing the following properties from type “Headers”: headers, singleValueHeaders, set, get and 16 others. ts(2345)
(parameter) requestConfiguration: Db_listRequestBuilderGetRequestConfiguration
Configuration for the request such as headers, query parameters, and middleware options.

@param requestConfiguration — Configuration for the request such as headers, query parameters, and middleware options.

Property “tryAddRequestHeaders” does not exist on type “RequestInformation”. Did you mean “addRequestHeaders”? ts(2551)
requestInformation.d.ts(39, 5): Declared “addRequestHeaders” here.

This is likely a bug due to incompatibility between the Kiota code generation tool and the Kiota dependency libraries. Therefore, manual fixes are necessary. Comment out the lines containing the following code:

requestInfo.addRequestHeaders(requestConfiguration.headers);
requestInfo.tryAddRequestHeaders

If there are parameters in the GET request, it can actually become quite tricky.

Thus, this request is incorrect:

var response = await myClient.account.add.get();

It should be used like this:

var response = await myClient.account.add.get({
    queryParameters: {
        name: datasource
    }
});

Because the generated code is quite convoluted.

Thus, when using it, you must carefully review the interface definitions in the code files...

Overall, it can identify various types of API interfaces and generate code, but the generated code has issues that require commenting out parts and is overly complex and cumbersome. It lacks the standardized output that other tools provide. The generated code is not "native" and must depend on using the SDK, making it quite heavy. Moreover, calling the generated API interfaces is troublesome and complicated! I also spent a long time figuring it out! Microsoft's tools remain, as always, convoluted!