Aller au contenu principal
Version: 3.0.0

API Development

Routing

In Midway Hooks, you can quickly create interfaces through the Api() function provided by @midwayjs/hooks.

Hello World example:

/src/hello.ts
import {
Api
Get
} from '@midwayjs/hooks';

export default Api (
Get(), // Http Path: /api/hello
async () => {
return 'Hello World!';
}
);

An API interface consists of the following parts:

  • Api(): defines an API function.
  • Get(path?: String): specifies the Http trigger, the request method is set to GET, and the optional path is the path of the interface. If you do not specify a path, the path is generated based on the function name and file name. By default, the path is prefixed with /API.
  • Handler: async (...args: any[]) => { ... }: user logic, processes requests and returns results

You can also specify the path, as shown in the following example.

/src/hello.ts
import {
Api
Get
} from '@midwayjs/hooks';

export default Api (
Get('/hello'), // Http Path: /hello
async () => {
return 'Hello World!';
}
);

Request context (Context / Request / Response)

You can get the request context object through the useContext provided by @midwayjs/hooks.

Taking Koa framework as an example, the useContext will return Koa's Context object.

Basic example:

  1. Get the request Method and Path
import {
Api
Get
useContext
} from '@midwayjs/hooks';
import { Context } from '@midwayjs/koa';

export default Api(Get(), async () => {
const ctx = useContext<Context>();
return {
method: ctx.method
path: ctx.path
};
});
  1. Set the returned Header
import {
Api
Get
useContext
} from '@midwayjs/hooks';

export default Api(Get(), async () => {
const ctx = useContext<Context>();
ctx.set('X-Powered-By', 'Midway');
return 'Hello World!';
});

At the same time, we can also set Header by SetHeader().

Http trigger

TriggerNotes
All(path?: string)Accept all Http Method requests
Get(path?: string)Accept GET request
Post(path?: string)Accept POST request
Put(path?: string)Accept PUT request
Delete(path?: string)Accept DELETE request
Patch(path?: string)Accept PATCH request
Head(path?: string)Accept HEAD request
Options(path?: string)Accept OPTIONS request

Request

Pass parameter Data

In Midway Hooks, the input parameter of the interface is the parameter that declares the function.

The basic example is as follows:

import {
Api
Post
} from '@midwayjs/hooks';

export default Api (
Post(), // Http Path: /api/say
async (name: string) => {
return 'Hello ${name}!';
}
);

You can call the interface in two ways.

  1. Full stack project: based on zero Api, import interface and call
  2. Manual call: Use fetch to Handler(...args: any[]) input parameters under Http, and you can pass parameters by setting the args parameter of Http Body during manual request.
import say from './api';

const response = await say('Midway');
console.log(response); // Hello Midway!

Query parameter Query

You can use the Query<T> parameter to pass the parameter to the URL.

If you want the interface path to be /articles? Page = 0 & limit = 10, you can write like this.

import {
Api
Get
Query
useContext
} from '@midwayjs/hooks';

export default Api (
Get()
Query< {
page: string;
limit: string;
}>(),
async () => {
const ctx = useContext();
return {
page: ctx.query.page
limit: ctx.query.limit
};
}
);

Front-end call

import getArticles from './api';
const response = await getArticles({
query: { page: '0', limit: '10'}
});
console.log(response); // { page: '0', limit: '10'}

Path parameter Params

Path parameters can realize the functions of dynamic paths and obtaining parameters from paths. When you use this feature, you must manually set the path and use Params<T> to declare the type.

If you want the interface path to be /article/100 and get a value with id 100, you can write as follows:

import {
Api
Get
Params
useContext
} from '@midwayjs/hooks';

export default Api (
Get('/article/:id')
Params<{ id: string }>()
async () => {
const ctx = useContext();
return {
article: ctx.params.id
};
}
);

Front-end call

import getArticle from './api/article';
const response = await getArticle({
params: { id: '100'}
});
console.log(response); // { article: '100'}

Request header Headers

The request header can realize the function of passing parameters through Http Headers. When using this function, the type must be declared by Headers<T>.

If you want to request /auth and pass token in the Request Headers, you can write as follows:

import {
Api
Get
Headers
useContext
} from '@midwayjs/hooks';

export default Api (
Get('/auth')
Headers<{ token: string }>()
async () => {
const ctx = useContext();
return {
token: ctx.headers.token
};
}
);

Front-end call

import getAuth from './api/auth';
const response = await getAuth({
headers: { token: '123456'}
});
console.log(response); // { token: '123456'}

Response Response

Status code HttpCode

HttpCode(status: number) is supported.

import {
Api
Get
HttpCode
} from '@midwayjs/hooks';

export default Api (
Get()
HttpCode(201)
async () => {
return 'Hello World!';
}
);

Response header SetHeader

SetHeader(key: string, value: string)

import {
Api
Get
SetHeader
} from '@midwayjs/hooks';

export default Api (
Get()
SetHeader('X-Powered-By', 'Midway')
async () => {
return 'Hello World!';
}
);

Redirect Redirect

Support: Redirect(url: string, code?: number = 302)

import {
Api
Get
Redirect
} from '@midwayjs/hooks';

export default Api (
Get('/demo')
Redirect('/hello')
async () => {}
);

Return value type ContentType

Supported: ContentType(type: string).

import {
Api
Get
ContentType
} from '@midwayjs/hooks';

export default Api (
Get()
ContentType('text/html')
async () => {
return '<h1>Hello World! </h1>';
}
);