API auto to TypeScript

openapi: 3.0.0
info:
  title: Simple User API
  version: 1.0.0
paths:
  /users:
    get:
      summary: Get all users
      responses:
        '200':
          description: A list of users
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/User'
    post:
      summary: Create a new user
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/NewUser'
      responses:
        '201':
          description: The created user
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/User'

components:
  schemas:
    User:
      type: object
      properties:
        id:
          type: integer
          example: 1
        name:
          type: string
          example: John Doe
        email:
          type: string
          example: john.doe@example.com
    NewUser:
      type: object
      properties:
        name:
          type: string
          example: John Doe
        email:
          type: string
          example: john.doe@example.com

import fs from 'node:fs';

import openapiTS, { astToString } from 'openapi-typescript';

const APIFOX_PROJECT_ID = process.env.APIFOX_PROJECT_ID;
const APIFOX_TOKEN = process.env.APIFOX_TOKEN;
if (!APIFOX_PROJECT_ID) {
	throw new Error('在.env.local 文件中添加 APIFOX_PROJECT_ID');
}
if (!APIFOX_TOKEN) {
	throw new Error('在.env.local 文件中添加 APIFOX_TOKEN');
}

const APIFOX_OPENAPI_PATH = `https://api.apifox.com/v1/projects/${APIFOX_PROJECT_ID}/export-openapi?locale=Zh-CN`;

async function main() {
	const headers = new Headers();
	headers.append('X-Apifox-Version', '2024-01-20');
	headers.append('Authorization', `Bearer ${APIFOX_TOKEN}`);
	headers.append('User-Agent', 'Apifox/1.0.0 (https://apifox.com)');
	headers.append('Accept', '*/*');
	headers.append('Host', 'api.apifox.com');
	headers.append('Connection', 'keep-alive');

	const requestOptions = {
		method: 'POST',
		headers,
		redirect: 'follow'
	};

	const data = await fetch(APIFOX_OPENAPI_PATH, requestOptions);
	const json = await data.json();
	const ast = await openapiTS(json);
	const content = astToString(ast);

	await fs.promises.writeFile('./openapi/api.ts', content);
}

main();

在 package.json 中新添加一个 script:

"scripts": {
	"api": "node --env-file .env.local script/api-to-ts.mjs",
}

npx openapi-typescript api.json -o api.ts

import { type paths } from './api';

export type UseAPIQueryOptions<T extends keyof paths> = paths[T]['get'] extends {
	parameters: infer P;
}
	? P extends { query?: infer Q }
		? Q
		: never
	: never;

/**
 * 获取 POST 请求的 Body 参数类型
 */
export type UseAPIPostBody<
	T extends keyof paths,
	Method extends keyof paths[T] = 'post'
> = paths[T][Method] extends {
	requestBody?: infer B;
}
	? B extends { content: { 'application/json': infer Req } }
		? Req
		: never
	: never;

import { ApiPaths, UseAPIPostBody, UseAPIQueryOptions, UseAPIResponse } from '@openapi/index';

interface RequestOptions extends RequestInit {
	responseType?: 'json' | 'text' | 'blob';
	customError?: boolean;
}

const request = async (url: string, options: RequestOptions = {}) => {
	// 具体的请求逻辑，包含鉴权、错误码处理等
};

/**
 * GET Request
 */
async function GET<P extends keyof ApiPaths>(
	url: P,
	params: UseAPIQueryOptions<P>,
	options?: RequestOptions
): Promise<UseAPIResponse<P>>;
async function GET<
	P extends string,
	R,
	T extends Record<string, unknown> = Record<string, unknown>
>(
	url: P,
	params: P extends keyof ApiPaths ? UseAPIQueryOptions<P> : T,
	options?: RequestOptions
): Promise<R>;
async function GET<
	P extends string,
	R,
	T extends Record<string, unknown> = Record<string, unknown>
>(
	url: P,
	params: P extends keyof ApiPaths ? UseAPIQueryOptions<P> : T,
	options?: RequestOptions
): Promise<R> {
	return await request(`${url}?${new URLSearchParams(params as Record<string, string>)}`, options);
}

/**
 * POST Request
 */
async function POST<P extends keyof ApiPaths>(
	url: P,
	body: UseAPIPostBody<P>,
	options?: RequestOptions
): Promise<UseAPIResponse<P, 'post'>>;
async function POST<
	P extends string,
	R,
	T extends Record<string, unknown> = Record<string, unknown>
>(
	url: P,
	body: P extends keyof ApiPaths ? UseAPIPostBody<P> : T,
	options?: RequestOptions
): Promise<R>;
async function POST<
	P extends string,
	R,
	T extends Record<string, unknown> = Record<string, unknown>
>(
	url: P,
	body: P extends keyof ApiPaths ? UseAPIPostBody<P> : T,
	options?: RequestOptions
): Promise<R> {
	return await request(url, {
		body: JSON.stringify(body),
		...options,
		method: 'POST'
	});
}

const HTTP = {
	GET,
	POST
};

export default HTTP;

export async function getListExampleTwo() {
	const data = await HTTP.GET('/val/match/home', {
		page: '1'
	});
	return data;
}

export const EXAMPLE_LIST = '/user/list';

export type ExampleResponseType = {
	name: string;
	job: string;
};

export async function getListExampleThree() {
	const data = await HTTP.GET<string, ExampleResponseType>(EXAMPLE_LIST, {
		age: 18,
		type: 'test'
	});
	return data;
}

export const EXAMPLE_LIST = '/user/list';

export async function getListExample(params: UseAPIQueryOptions<EXAMPLE_LIST>) {
	const data = await HTTP.GET(EXAMPLE_LIST, params);
	return data;
}

export async function getDetail(id: string) {
	const detail = await HTTP.GET<string, UseAPIResponse<'/user/info', 'get'>>(
		`/user/info/${id}`,
		{}
	);
	return detail;
}

"scripts": {
    "lint": "pnpm run check-types && next lint",
    "check-types": "tsc --noemit",
}